Skip to content

brycewang-stanford/Auto-Empirical-Research-Skills / skills/35-bahayonghang-academic-writing-skills/skills/latex-thesis-zh

latex-thesis-zh

Verified

Chinese LaTeX thesis assistant for existing .tex degree thesis projects (XeLaTeX/LuaLaTeX/latexmk). Use this skill whenever a user works on a Chinese master's or doctoral thesis needing compilation, GB/T 7714 bibliography checks, chapter structure mapping, template detection (thuthesis, pkuthss), terminology consistency, logic coherence review, heading lead-in checks, title optimization, de-AI editing, experiment chapter review, three-line table validation, or abstract structure diagnosis. Trigger even for single issues like "帮我编译论文", "检查国标格式", "看看绪论逻辑", "毕业论文", "学位论文", "硕士/博士论文", "三线表", "检查摘要", or "摘要结构".

FileKindSize
SKILL.mdskill md7.8 KB
agents/openai.yamlconfig348 B
evals/evals.jsonconfig7.1 KB
examples/bibliography-and-deai.mdmarkdown525 B
examples/compile-and-template.mdmarkdown463 B
examples/structure-and-consistency.mdmarkdown544 B
references/ABSTRACT_STRUCTURE.mdmarkdown4.9 KB
references/ACADEMIC_STYLE_ZH.mdmarkdown3.8 KB
references/CAPTION_GUIDE.mdmarkdown2.2 KB
references/COMPILATION.mdmarkdown2.0 KB
references/DEAI_GUIDE.mdmarkdown17.8 KB
references/FORBIDDEN_TERMS.mdmarkdown1.3 KB
references/GB_STANDARD.mdmarkdown3.8 KB
references/LOGIC_COHERENCE.mdmarkdown7.4 KB
references/STRUCTURE_GUIDE.mdmarkdown4.2 KB
references/TABLE_GUIDE.mdmarkdown2.6 KB
references/TITLE_OPTIMIZATION.mdmarkdown7.1 KB
references/UNIVERSITIES/generic.mdmarkdown2.1 KB
references/UNIVERSITIES/pku.mdmarkdown1.5 KB
references/UNIVERSITIES/tsinghua.mdmarkdown1.3 KB
references/UNIVERSITIES/yanshan.mdmarkdown1.2 KB
references/WRITING_PHILOSOPHY_ZH.mdmarkdown4.9 KB
references/modules/ABSTRACT.mdmarkdown1.2 KB
references/modules/BIBLIOGRAPHY.mdmarkdown1.3 KB
references/modules/COMPILE.mdmarkdown1.1 KB
references/modules/CONSISTENCY.mdmarkdown2.1 KB
references/modules/DEAI.mdmarkdown1.6 KB
references/modules/EXPERIMENT.mdmarkdown4.9 KB
references/modules/FORMAT.mdmarkdown988 B
references/modules/LOGIC.mdmarkdown2.3 KB
references/modules/TABLES.mdmarkdown1.3 KB
references/modules/TEMPLATE.mdmarkdown1.3 KB
references/modules/TITLE.mdmarkdown1.5 KB
scripts/analyze_abstract.pyscript17.3 KB
scripts/analyze_experiment.pyscript10.3 KB
scripts/analyze_logic.pyscript24.2 KB
scripts/check_consistency.pyscript12.1 KB
scripts/check_format.pyscript7.0 KB
scripts/check_references.pyscript17.6 KB
scripts/check_tables.pyscript16.3 KB
scripts/compile.pyscript15.8 KB
scripts/deai_batch.pyscript10.0 KB
scripts/deai_check.pyscript18.1 KB
scripts/detect_template.pyscript3.7 KB
scripts/generate_table.pyscript8.8 KB
scripts/map_structure.pyscript11.3 KB
scripts/online_bib_verify.pyscript11.9 KB
scripts/optimize_title.pyscript12.5 KB
scripts/parsers.pyscript10.7 KB
scripts/verify_bib.pyscript9.7 KB

scripts/check_format.py

View on GitHub
#!/usr/bin/env python3
"""
LaTeX Format Checker (Chinese) - chktex wrapper with Chinese support

Usage:
    uv run python check_format.py main.tex
    uv run python check_format.py main.tex --strict
"""

import argparse
import re
import shutil
import subprocess
import sys
from pathlib import Path
from typing import Optional


class FormatChecker:
    """ChkTeX wrapper with Chinese thesis specific checks."""

    # Chinese-specific checks (in addition to chktex)
    CHINESE_CHECKS = {
        "mixed_punctuation": {
            "pattern": r"[\u4e00-\u9fff][,.:;!?]|[,.:;!?][\u4e00-\u9fff]",
            "message": "Mixed Chinese/English punctuation detected",
            "severity": "warning",
        },
        "missing_space_after_cite": {
            "pattern": r"\\cite\{[^}]+\}[\u4e00-\u9fff]",
            "message": "Missing space after \\cite before Chinese text",
            "severity": "info",
        },
        "oral_expression": {
            "pattern": r"我们|你们|很多|一些|非常|特别",
            "message": "Potential oral expression in academic writing",
            "severity": "warning",
        },
    }

    def __init__(self, tex_file: str, config: Optional[str] = None):
        self.tex_file = Path(tex_file).resolve()
        self.work_dir = self.tex_file.parent
        self.config = config

    def _check_chktex(self) -> tuple[bool, str]:
        """Check if chktex is available."""
        if shutil.which("chktex"):
            return True, "chktex is available"
        return False, "chktex not found"

    def check(self, strict: bool = False) -> dict:
        """Run format checks including Chinese-specific ones."""
        all_issues = []

        # Run chktex if available
        ok, msg = self._check_chktex()
        if ok:
            chktex_issues = self._run_chktex(strict)
            all_issues.extend(chktex_issues)

        # Run Chinese-specific checks
        chinese_issues = self._run_chinese_checks()
        all_issues.extend(chinese_issues)

        return {
            "status": "PASS" if not all_issues else "WARNING",
            "chktex_available": ok,
            "issues": all_issues,
            "total": len(all_issues),
        }

    def _run_chktex(self, strict: bool) -> list[dict]:
        """Run chktex and parse output."""
        cmd = ["chktex"]
        if strict:
            cmd.extend(["-v3"])
        else:
            cmd.extend(["-v0", "-q"])
        cmd.append(str(self.tex_file))

        try:
            result = subprocess.run(
                cmd,
                cwd=self.work_dir,
                capture_output=True,
                text=True,
                encoding="utf-8",
                errors="replace",
            )
            return self._parse_chktex_output(result.stdout + result.stderr)
        except Exception:
            return []

    def _parse_chktex_output(self, output: str) -> list[dict]:
        """Parse chktex output."""
        issues = []
        pattern = r"(.+?):(\d+):(\d+):\s*(Warning|Error)\s*(\d+):\s*(.+)"

        for line in output.split("\n"):
            match = re.match(pattern, line.strip())
            if match:
                issues.append(
                    {
                        "source": "chktex",
                        "file": match.group(1),
                        "line": int(match.group(2)),
                        "column": int(match.group(3)),
                        "severity": match.group(4).lower(),
                        "code": int(match.group(5)),
                        "message": match.group(6),
                    }
                )

        return issues

    def _run_chinese_checks(self) -> list[dict]:
        """Run Chinese-specific checks."""
        issues = []

        try:
            content = self.tex_file.read_text(encoding="utf-8", errors="ignore")
        except Exception:
            return issues

        lines = content.split("\n")

        for check_name, check_info in self.CHINESE_CHECKS.items():
            pattern = check_info["pattern"]

            for i, line in enumerate(lines, 1):
                # Skip comments
                if line.strip().startswith("%"):
                    continue

                for match in re.finditer(pattern, line):
                    issues.append(
                        {
                            "source": "chinese_check",
                            "file": str(self.tex_file.name),
                            "line": i,
                            "column": match.start() + 1,
                            "severity": check_info["severity"],
                            "code": check_name,
                            "message": check_info["message"],
                            "matched": match.group(),
                        }
                    )

        return issues

    def generate_report(self, result: dict) -> str:
        """Generate human-readable report."""
        lines = []
        lines.append("=" * 60)
        lines.append("LaTeX Format Check Report (Chinese Thesis)")
        lines.append("=" * 60)
        lines.append(f"File: {self.tex_file}")
        lines.append(f"Status: {result['status']}")
        lines.append(f"ChkTeX: {'Available' if result['chktex_available'] else 'Not Available'}")
        lines.append(f"Total Issues: {result['total']}")

        if result["issues"]:
            lines.append("")
            lines.append("-" * 60)
            lines.append("Issues:")
            lines.append("-" * 60)

            # Group by source
            by_source = {}
            for issue in result["issues"]:
                source = issue["source"]
                if source not in by_source:
                    by_source[source] = []
                by_source[source].append(issue)

            for source, issues in by_source.items():
                lines.append(f"\n[{source.upper()}] ({len(issues)} issues)")
                for issue in issues[:10]:
                    sev = issue["severity"].upper()
                    lines.append(f"  [{sev}] Line {issue['line']}: {issue['message']}")
                if len(issues) > 10:
                    lines.append(f"  ... and {len(issues) - 10} more")

        lines.append("")
        lines.append("=" * 60)
        return "\n".join(lines)


def main():
    parser = argparse.ArgumentParser(description="LaTeX Format Checker (Chinese Thesis)")
    parser.add_argument("tex_file", help=".tex file to check")
    parser.add_argument("--strict", "-s", action="store_true", help="Enable strict checking")
    parser.add_argument("--json", "-j", action="store_true", help="Output in JSON format")

    args = parser.parse_args()

    if not Path(args.tex_file).exists():
        print(f"[ERROR] File not found: {args.tex_file}")
        sys.exit(1)

    checker = FormatChecker(args.tex_file)
    result = checker.check(strict=args.strict)

    if args.json:
        import json

        print(json.dumps(result, indent=2, ensure_ascii=False))
    else:
        print(checker.generate_report(result))

    sys.exit(0 if result["status"] == "PASS" else 1)


if __name__ == "__main__":
    main()
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 323kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 323kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 323kUpdated Claude CodeCodexVerifiedInstall