Skip to content

brycewang-stanford/Auto-Empirical-Research-Skills / skills/35-bahayonghang-academic-writing-skills/skills/typst-paper

typst-paper

Verified

Typst academic paper assistant for existing `.typ` paper projects in English or Chinese. Use this skill whenever the user wants to compile, audit, or improve a Typst paper, including format checks, bibliography validation for BibTeX or Hayagriva, grammar/sentence/logic review, expression polishing, translation, title optimization, pseudocode review, algorithm block cleanup, de-AI editing, experiment-section review, table structure validation, three-line table generation, abstract structure diagnosis, or journal adaptation. Trigger even when the user only mentions one Typst file, one bibliography issue, one pseudocode block, one section rewrite, "three-line table", "check abstract", or "reformat for another journal". Also trigger when the user mentions ".typ files", "typst compile error", "typst export", "typst bibliography", `algorithm-figure`, `lovelace`, or `algorithmic` even without saying the word "Typst" explicitly.

FileKindSize
SKILL.mdskill md7.5 KB
agents/openai.yamlconfig330 B
evals/evals.jsonconfig7.3 KB
examples/bibliography-and-title.mdmarkdown509 B
examples/compile-and-format.mdmarkdown495 B
examples/expression-and-translation.mdmarkdown554 B
references/ABSTRACT_STRUCTURE.mdmarkdown4.9 KB
references/BEST_PRACTICES.mdmarkdown391 B
references/CITATION_STYLES.mdmarkdown4.2 KB
references/CITATION_VERIFICATION.mdmarkdown4.9 KB
references/COMMON_ERRORS.mdmarkdown5.3 KB
references/DEAI_GUIDE.mdmarkdown14.9 KB
references/JOURNAL_ABBREVIATIONS.mdmarkdown3.5 KB
references/JOURNAL_ADAPTATION_WORKFLOW.mdmarkdown3.6 KB
references/NUMBER_UNIT_GUIDE.mdmarkdown2.3 KB
references/REVIEWER_PERSPECTIVE.mdmarkdown4.9 KB
references/STYLE_GUIDE.mdmarkdown7.9 KB
references/TABLE_GUIDE.mdmarkdown2.6 KB
references/TEMPLATES.mdmarkdown2.5 KB
references/TERMINOLOGY.mdmarkdown9.9 KB
references/TRANSLATION_GUIDE.mdmarkdown11.4 KB
references/TYPST_SYNTAX.mdmarkdown9.8 KB
references/VENUES.mdmarkdown13.0 KB
references/WRITING_PHILOSOPHY.mdmarkdown6.7 KB
references/modules/ABSTRACT.mdmarkdown1.2 KB
references/modules/ADAPT.mdmarkdown1.3 KB
references/modules/BIBLIOGRAPHY.mdmarkdown1.3 KB
references/modules/CAPTION.mdmarkdown2.1 KB
references/modules/COMPILE.mdmarkdown1.2 KB
references/modules/DEAI.mdmarkdown2.8 KB
references/modules/EXPERIMENT.mdmarkdown3.8 KB
references/modules/EXPRESSION.mdmarkdown1.6 KB
references/modules/FORMAT.mdmarkdown1.1 KB
references/modules/GRAMMAR.mdmarkdown1.1 KB
references/modules/LOGIC.mdmarkdown5.4 KB
references/modules/PSEUDOCODE.mdmarkdown1.4 KB
references/modules/SENTENCES.mdmarkdown726 B
references/modules/TABLES.mdmarkdown1.3 KB
references/modules/TITLE.mdmarkdown7.3 KB
references/modules/TRANSLATION.mdmarkdown1.5 KB
references/modules/WORKFLOW.mdmarkdown706 B
scripts/analyze_abstract.pyscript17.3 KB
scripts/analyze_experiment.pyscript11.1 KB
scripts/analyze_grammar.pyscript3.6 KB
scripts/analyze_logic.pyscript18.8 KB
scripts/analyze_sentences.pyscript3.6 KB
scripts/check_format.pyscript11.3 KB
scripts/check_pseudocode.pyscript8.6 KB
scripts/check_references.pyscript14.1 KB
scripts/check_tables.pyscript9.8 KB
scripts/compile.pyscript8.1 KB
scripts/deai_batch.pyscript10.2 KB
scripts/deai_check.pyscript19.2 KB
scripts/generate_table.pyscript6.7 KB
scripts/improve_expression.pyscript3.2 KB
scripts/online_bib_verify.pyscript11.9 KB
scripts/optimize_title.pyscript16.9 KB
scripts/parsers.pyscript8.0 KB
scripts/translate_academic.pyscript4.2 KB
scripts/verify_bib.pyscript15.1 KB

scripts/deai_batch.py

View on GitHub
#!/usr/bin/env python3
"""
De-AI Batch Processor for Typst Academic Papers
Batch processes entire Typst chapters or documents.

Usage:
    uv run python deai_batch.py main.typ --chapter chapter3/introduction.typ
    uv run python deai_batch.py main.typ --all-sections
    uv run python deai_batch.py main.typ --section introduction --output polished/
"""

import argparse
import re
import sys
from pathlib import Path

# Import local parsers
try:
    from parsers import get_parser
except ImportError:
    sys.path.append(str(Path(__file__).parent))
    from parsers import get_parser


class DeAIBatchProcessor:
    """Batch process Typst files for de-AI editing."""

    def __init__(self, file_path: Path):
        self.file_path = file_path
        self.content = file_path.read_text(encoding="utf-8", errors="ignore")
        self.lines = self.content.split("\n")
        self.parser = get_parser(file_path)
        self.section_ranges = self.parser.split_sections(self.content)
        self.comment_prefix = self.parser.get_comment_prefix()

    def analyze_section(self, section_name: str) -> dict:
        """Analyze a section for AI traces."""
        if section_name not in self.section_ranges:
            return {
                "section": section_name,
                "found": False,
                "lines": 0,
                "traces": [],
            }

        start, end = self.section_ranges[section_name]
        traces = []

        # Get lines for this section
        # Convert 1-based lines to 0-based index
        section_lines = self.lines[start - 1 : end]
        line_num = start

        for line in section_lines:
            stripped = line.strip()
            if not stripped or stripped.startswith(self.comment_prefix):
                line_num += 1
                continue

            visible = self.parser.extract_visible_text(stripped)
            ai_patterns = self._check_ai_patterns(visible)

            if ai_patterns:
                traces.append(
                    {
                        "line": line_num,
                        "original": stripped,
                        "visible": visible,
                        "patterns": ai_patterns,
                    }
                )

            line_num += 1

        return {
            "section": section_name,
            "found": True,
            "lines": end - start + 1,
            "traces": traces,
        }

    def _check_ai_patterns(self, text: str) -> list[str]:
        """Check text for AI writing patterns."""
        patterns = []

        # Empty phrases
        empty_phrases = [
            r"significant (?:improvement|performance|gain)",
            r"comprehensive (?:analysis|study)",
            r"effective (?:solution|method)",
            r"important (?:contribution|role)",
            r"robust performance",
            r"novel approach",
            r"state-of-the-art",
        ]

        # Over-confident
        over_confident = [
            r"\bobviously\b",
            r"\bclearly\b",
            r"\bcertainly\b",
            r"\bundoubtedly\b",
        ]

        # Vague quantifiers
        vague_quantifiers = [
            r"\bmany studies\b",
            r"\bnumerous experiments\b",
            r"\bvarious methods\b",
            r"\bseveral approaches\b",
        ]

        # Template expressions
        template_exprs = [
            r"\bin recent years\b",
            r"\bmore and more\b",
            r"\bplays? an important role\b",
            r"\bwith the (?:rapid )?development of\b",
        ]

        all_checks = [
            ("empty_phrase", empty_phrases),
            ("over_confident", over_confident),
            ("vague_quantifier", vague_quantifiers),
            ("template_expr", template_exprs),
        ]

        for category, pattern_list in all_checks:
            for pattern in pattern_list:
                if re.search(pattern, text, re.IGNORECASE):
                    patterns.append(f"{category}: {pattern}")

        return patterns

    def generate_batch_report(self, analyses: dict[str, dict]) -> str:
        """Generate batch processing report."""
        report = []
        report.append("=" * 70)
        report.append("DE-AI BATCH PROCESSING REPORT (Typst)")
        report.append("=" * 70)
        report.append(f"Source file: {self.file_path}")
        report.append("")

        total_traces = 0
        total_lines = 0

        for section_name, analysis in analyses.items():
            if not analysis["found"]:
                continue

            trace_count = len(analysis["traces"])
            total_traces += trace_count
            total_lines += analysis["lines"]

            density = (trace_count / analysis["lines"] * 100) if analysis["lines"] > 0 else 0

            report.append(f"\n{'─' * 70}")
            report.append(f"SECTION: {section_name.upper()}")
            report.append(f"{'─' * 70}")
            report.append(f"Lines: {analysis['lines']}")
            report.append(f"AI traces detected: {trace_count}")
            report.append(f"Density: {density:.1f}%")

            if trace_count > 0:
                report.append("\nTraces (first 5):")
                for i, trace in enumerate(analysis["traces"][:5], 1):
                    report.append(f"\n  [{i}] Line {trace['line']}")
                    report.append(f"      Patterns: {', '.join(trace['patterns'])}")
                    report.append(f"      Visible: {trace['visible'][:100]}")

        report.append("\n" + "=" * 70)
        report.append("SUMMARY")
        report.append("=" * 70)
        report.append(f"Total lines analyzed: {total_lines}")
        report.append(f"Total AI traces: {total_traces}")
        overall_density = (total_traces / total_lines * 100) if total_lines > 0 else 0
        report.append(f"Overall density: {overall_density:.1f}%")

        return "\n".join(report)

    def process_section_file(self, chapter_file: Path, output_dir: Path) -> bool:
        """Process a single chapter file."""
        if not chapter_file.exists():
            print(f"[ERROR] Chapter file not found: {chapter_file}")
            return False

        # Determine parser for the chapter file specifically
        chapter_parser = get_parser(chapter_file)
        comment_prefix = chapter_parser.get_comment_prefix()

        content = chapter_file.read_text(encoding="utf-8")
        lines = content.split("\n")

        processed_lines = []
        modifications = []

        for i, line in enumerate(lines, 1):
            stripped = line.strip()

            if not stripped or stripped.startswith(comment_prefix):
                processed_lines.append(line)
                continue

            visible = chapter_parser.extract_visible_text(stripped)
            patterns = self._check_ai_patterns(visible)

            if patterns:
                comment = f"{comment_prefix} DE-AI: Line {i} - {', '.join(patterns)}"
                processed_lines.append(comment)
                processed_lines.append(line)
                modifications.append(
                    {
                        "line": i,
                        "patterns": patterns,
                        "original": stripped,
                    }
                )
            else:
                processed_lines.append(line)

        output_file = output_dir / chapter_file.name
        output_file.write_text("\n".join(processed_lines), encoding="utf-8")

        print(f"[SUCCESS] Processed: {chapter_file.name}")
        print(f"         Output: {output_file}")
        print(f"         Modifications: {len(modifications)}")

        return True


def main():
    parser = argparse.ArgumentParser(description="Batch process Typst documents for de-AI editing")

    parser.add_argument("file", type=Path, help="Main Typst file (.typ)")
    parser.add_argument("--chapter", type=Path, help="Process specific chapter file")
    parser.add_argument("--all-sections", action="store_true", help="Analyze all sections")
    parser.add_argument("--section", type=str, help="Analyze specific section")
    parser.add_argument("--output", type=Path, help="Output directory for processed files")
    parser.add_argument("--report", type=Path, help="Save report to file")

    args = parser.parse_args()

    if not args.file.exists():
        print(f"[ERROR] File not found: {args.file}", file=sys.stderr)
        sys.exit(1)

    if not str(args.file).lower().endswith(".typ"):
        print(f"[WARNING] Expected .typ file, got: {args.file}", file=sys.stderr)

    processor = DeAIBatchProcessor(args.file)

    if args.all_sections:
        analyses = {}
        for section_name in processor.section_ranges:
            analyses[section_name] = processor.analyze_section(section_name)

        report = processor.generate_batch_report(analyses)

        if args.report:
            args.report.write_text(report, encoding="utf-8")
            print(f"[SUCCESS] Report saved to: {args.report}")
        else:
            print(report)

    elif args.chapter:
        if not args.output:
            print("[ERROR] --output required when processing chapter file")
            sys.exit(1)

        args.output.mkdir(parents=True, exist_ok=True)
        success = processor.process_section_file(args.chapter, args.output)
        sys.exit(0 if success else 1)

    elif args.section:
        analysis = processor.analyze_section(args.section.lower())

        if not analysis["found"]:
            print(f"[WARNING] Section not found: {args.section}")
            sys.exit(1)

        print(f"\nSection: {args.section}")
        print(f"Lines: {analysis['lines']}")
        print(f"AI traces: {len(analysis['traces'])}\n")

        for trace in analysis["traces"][:10]:
            print(f"Line {trace['line']}:")
            print(f"  Patterns: {', '.join(trace['patterns'])}")
            print(f"  Text: {trace['visible'][:100]}")
            print()

    else:
        print(f"[INFO] Available sections in {args.file.name}:")
        for section_name in processor.section_ranges:
            start, end = processor.section_ranges[section_name]
            print(f"  - {section_name}: lines {start}-{end}")
        print()
        print("[INFO] Use --all-sections for full analysis")
        print("[INFO] Use --section <name> for specific section")
        print("[INFO] Use --chapter <file> --output <dir> to process chapter")


if __name__ == "__main__":
    main()
rea-analysis-optimizationmorluto/reaOptimize REA providers and shared analysis workflows for agent context, latency, CPU, and memory while preserving correctness and Evidence. Use for analysis bottlenecks and cache or query design; CI/test-suite optimization belongs to rea-ci-tests-audit.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
rea-ci-tests-auditmorluto/reaAudit REA CI and test suites for correctness, fixture drift, false passes, and measured performance; use for suite or workflow investigations and efficiency changes, rather than ordinary feature testing or a single test failure.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
rea-tool-designmorluto/reaAudit, investigate, design, or change REA investigation tools, CLI/MCP contracts, provider capabilities, and Evidence semantics.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
ponytail-auditDietrichGebert/ponytailQuality audit of the whole repo: bugs, security, real load, missing tests, speed, and what to delete. Most important first.Stars: 194kUpdated Claude CodeCodexVerifiedInstall