Paper Compilation

#!/usr/bin/env python3
"""Compile a LaTeX paper to PDF with error detection.

Runs the full pdflatex → bibtex → pdflatex → pdflatex pipeline,
reports errors, and optionally runs chktex for style checking.

Self-contained: uses only stdlib.

Adapted from AI-Scientist (compile_latex) and data-to-paper (save_latex_and_compile_to_pdf).

Usage:
    python compile_paper.py paper/main.tex
    python compile_paper.py paper/main.tex --check-style
    python compile_paper.py paper/main.tex --output paper/output.pdf
"""

import argparse
import os
import re
import shutil
import subprocess
import sys


def run_command(cmd: list[str], cwd: str, timeout: int = 60) -> tuple[int, str, str]:
    """Run a command and return (returncode, stdout, stderr)."""
    try:
        result = subprocess.run(
            cmd, cwd=cwd,
            stdout=subprocess.PIPE, stderr=subprocess.PIPE,
            text=True, timeout=timeout,
        )
        return result.returncode, result.stdout, result.stderr
    except subprocess.TimeoutExpired:
        return -1, "", f"Command timed out after {timeout}s: {' '.join(cmd)}"
    except FileNotFoundError:
        return -2, "", f"Command not found: {cmd[0]}"


def check_bib_exists(tex_content: str) -> bool:
    """Check if the tex file references a bibliography."""
    return bool(re.search(r"\\bibliography\{", tex_content) or
                re.search(r"\\begin\{filecontents\}\{.*\.bib\}", tex_content) or
                re.search(r"\\addbibresource\{", tex_content))


def extract_errors(log_content: str) -> list[str]:
    """Extract LaTeX errors from log file."""
    errors = []
    lines = log_content.split("\n")
    for i, line in enumerate(lines):
        if line.startswith("! "):
            # Grab the error line and a few lines of context
            context = lines[i:i+5]
            errors.append("\n".join(context))
    return errors


def extract_warnings(log_content: str) -> list[str]:
    """Extract significant warnings from log file."""
    warnings = []
    for line in log_content.split("\n"):
        line = line.strip()
        if "Overfull \\hbox" in line:
            warnings.append(line)
        elif "Underfull \\vbox" in line:
            warnings.append(line)
        elif "Citation" in line and "undefined" in line:
            warnings.append(line)
        elif "Reference" in line and "undefined" in line:
            warnings.append(line)
        elif "LaTeX Warning: There were undefined references" in line:
            warnings.append(line)
    return warnings


def count_pages(pdf_path: str) -> int | None:
    """Try to count PDF pages using python."""
    try:
        with open(pdf_path, "rb") as f:
            content = f.read()
        # Simple heuristic: count /Type /Page entries
        count = len(re.findall(rb"/Type\s*/Page[^s]", content))
        return count if count > 0 else None
    except Exception:
        return None


def compile_latex(tex_file: str, output_pdf: str | None = None,
                  check_style: bool = False, timeout: int = 60) -> bool:
    """Compile LaTeX to PDF. Returns True on success."""
    tex_file = os.path.abspath(tex_file)
    if not os.path.exists(tex_file):
        print(f"Error: {tex_file} not found", file=sys.stderr)
        return False

    cwd = os.path.dirname(tex_file)
    basename = os.path.splitext(os.path.basename(tex_file))[0]

    with open(tex_file, encoding="utf-8", errors="replace") as f:
        tex_content = f.read()

    has_bib = check_bib_exists(tex_content)

    # Build compilation sequence
    commands = [
        ["pdflatex", "-interaction=nonstopmode", "-halt-on-error", os.path.basename(tex_file)],
    ]
    if has_bib:
        commands.append(["bibtex", basename])
        commands.append(["pdflatex", "-interaction=nonstopmode", os.path.basename(tex_file)])
    commands.append(["pdflatex", "-interaction=nonstopmode", os.path.basename(tex_file)])

    print(f"Compiling {tex_file}")
    print(f"  Working directory: {cwd}")
    pr