Content Proofreading

Source: https://github.com/aipoch/medical-research-skills

When to Use

• You are preparing an academic paper for journal/conference submission and need a final language + formatting pass.
• You have bilingual (Chinese/English) content and want consistent punctuation, wording, and style across both languages.
• Your manuscript contains domain terminology (e.g., life sciences) and you need consistent Chinese–English term mapping and abbreviation rules.
• You need to validate references, numbers/units, and heading levels against a required style (APA/MLA/GB/T 7714).
• You want a shareable report (HTML or Markdown annotations) with precise error locations and revision suggestions.

Agent Workflow

Follow these steps in order when the user provides text for proofreading:

Step 1: Identify Input Source

• Determine if the user pasted text directly, provided a file path, or attached a .docx/.md file.
• If a file path is given, read the file content. If a .docx file, use word_converter.py to extract text first.
• If the user provided only text inline, use that text directly.

Step 2: Determine Language Scope

• Check if the content is English, Chinese, or bilingual (both).
• Set language parameter accordingly: en, zh, or both.
• If the user did not specify, auto-detect from content.

Step 3: Run English Checks (if applicable)

• If English content is detected, call EnglishChecker().check(text) to check:
  • Spelling (US/UK variants)
  • Grammar (agreement, tense, articles)
  • Punctuation (US/UK conventions)
  • Style (redundancy, passive voice)
• Collect all findings with location, type, and suggested fix.

Step 4: Run Chinese Checks (if applicable)

• If Chinese content is detected, call ChineseChecker().check(text) to check:
  • Typo/misused characters
  • Grammar and collocation
  • Chinese vs English punctuation normalization
  • Academic expression optimization
• Collect all findings.

Step 5: Run Terminology Check

• Call TerminologyManager(domain="biology").check(text) to verify:
  • Bidirectional Chinese–English term correspondence
  • Abbreviation rule compliance (full form on first occurrence)
  • Synonym unification to preferred standard terms
• Collect all findings.

Step 6: Generate Report

• Feed all findings to AnnotationGenerator(output_format="html" or "markdown").
• Generate the report showing:
  • Each issue with precise location (line/offset)
  • Issue type (spelling, grammar, terminology, formatting)
  • Suggested fix
• Present the report to the user. If the user requested an HTML file, save and return the file path.

Step 7: Validate Output

• Verify all detected issues have location + type + fix.
• Confirm the output format matches the user's request (HTML/Markdown).
• If partial, label clearly as PARTIAL.

Key Features

• English checks

  • Spelling (including US/UK variants)
  • Grammar (agreement, tense, articles, clause structure)
  • Punctuation conventions (US/UK)
  • Style suggestions (redundancy detection, passive voice optimization)

• Chinese checks

  • Typo/misused character detection (dictionary-based)
  • Grammar and collocation checks
  • Chinese vs. English punctuation normalization
  • Academic expression optimization suggestions

• Terminology consistency

  • Domain terminology database (life sciences by default)
  • Bidirectional Chinese–English correspondence checks
  • Abbreviation rules (require full form on first occurrence)
  • Synonym unification to preferred standard terms

• Formatting checks

  • Reference style validation (APA/MLA/GB/T 7714, etc.)
  • Number and unit normalization
  • Heading level consistency
  • Abbreviation consistency across the document

• Reporting

  • HTML interactive report or Markdown annotations
  • Precise error localization
  • Actionable revision suggestions

Dependencies

• Python: >= 3.8

• Python packages (install via pip install -r requirements.txt)

  • languagetool-python (version: see requirements.txt) — English grammar checking
  • opencc (version: see requirements.txt) — Traditional/Simplified Chinese conversion
  • jieba (version: see requirements.txt) — Chinese tokenization
  • pyenchant (version: see requirements.txt) — spelling checks
  • markdown (version: see requirements.txt) — Markdown rendering
  • python-docx (version: see requirements.txt) — .docx reading
  • docx2pdf (version: see requirements.txt) — Word-to-PDF conversion

Example Usage

1) Install

python -m venv .venv
source .venv/bin/activate  # Windows: .venv\Scripts\activate

pip install -r requirements.txt

2) Run (basic)

python scripts/init_run.py --input <paper_file_path> --output <output_path>

3) Run (advanced)

python scripts/init_run.py \
  --input paper.md \
  --output report.html \
  --lang en \
  --style apa \
  --terminology biology \
  --format html

4) CLI parameters

5) Use as a Python module (end-to-end)

from scripts.english_checker import EnglishChecker
from scripts.chinese_checker import ChineseChecker
from scripts.terminology_manager import TerminologyManager
from scripts.annotation_generator import AnnotationGenerator

text = """
Messenger RNA (mRNA) is transcribed in the nucleus.
"""

en_checker = EnglishChecker()
zh_checker = ChineseChecker()
term_manager = TerminologyManager(domain="biology")

results = []
results.extend(en_checker.check(text))
results.extend(zh_checker.check(text))
results.extend(term_manager.check(text))

generator = AnnotationGenerator(output_format="html")
report = generator.generate(results)

with open("report.html", "w", encoding="utf-8") as f:
    f.write(report)

Implementation Details

Architecture / Core Modules

• english_checker.py

  • Core engine for English spelling/grammar/style checks.
  • Designed to be rule-extensible (add or register new rule sets).

• chinese_checker.py

  • Core engine for Chinese typo/grammar/style checks.
  • Includes a library of common academic writing error patterns.

• terminology_manager.py

  • Terminology database management (import/export/query/update).
  • Performs term consistency checks, bilingual mapping validation, and abbreviation policy checks.

• annotation_generator.py

  • Converts detected issues into a visual report (HTML) or annotated Markdown.
  • Ensures issues include location, type, and suggested fix.

• word_converter.py

  • Extracts text from .docx.
  • Optionally converts Word to PDF (can be disabled via --no-pdf).

Terminology database format (JSON)

Organized by domain; each entry can include bilingual forms and abbreviation metadata:

{
  "biology": {
    "cell": {
      "en": "cell",
      "abbrev": null,
      "full_form": null
    },
    "mrna": {
      "en": "mRNA",
      "abbrev": "mRNA",
      "full_form": "messenger RNA"
    }
  }
}

Checking logic (typical):

• If an abbreviation (e.g., mRNA) appears, verify the full form appears at first mention (e.g., messenger RNA (mRNA)).
• If both Chinese and English terms appear, verify they match the configured mapping for the selected domain.
• If synonyms are detected, prefer the standardized term defined in the database.