@litfamily/lithermes 1.0.7 → 1.0.9

package/assets/lithermes-plugin/skills/lit-docx/scripts/convert_md_to_pdf.py

@@ -0,0 +1,281 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+from convert_md_to_docx import (
+    detect_locale,
+    fix_dashes,
+    fix_ellipsis,
+    fix_quotes,
+    fix_unit_spacing,
+    load_publisher,
+    normalize_double_spaces,
+    parse_frontmatter,
+)
+
+
+def command_path(name: str) -> str | None:
+    return shutil.which(name)
+
+
+def run_checked(command: list[str], workdir: Path | None = None) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        command,
+        cwd=str(workdir) if workdir else None,
+        text=True,
+        capture_output=True,
+        check=False,
+    )
+
+
+def ensure_pandoc() -> None:
+    if not command_path("pandoc"):
+        raise SystemExit("Error: pandoc not found. Install pandoc to use convert_md_to_pdf.py")
+
+
+def preprocess_markdown(md_path: Path, publisher: dict, locale: str) -> tuple[dict, str, str]:
+    md_text = md_path.read_text(encoding="utf-8")
+    frontmatter, body = parse_frontmatter(md_text)
+    detected_locale = detect_locale(body) if locale == "auto" else locale
+    design = publisher["design"]
+    dash_rules = design.get("micro_typography", {}).get("dashes")
+    body = fix_dashes(body, dash_rules)
+    body = fix_quotes(body)
+    body = fix_unit_spacing(body)
+    body = fix_ellipsis(body)
+    body = normalize_double_spaces(body)
+    return frontmatter, body, detected_locale
+
+
+def format_author_meta(frontmatter: dict) -> str:
+    authors = frontmatter.get("authors") or []
+    if not isinstance(authors, list):
+        return str(authors)
+    items: list[str] = []
+    for author in authors:
+        if isinstance(author, dict):
+            name = str(author.get("name") or "").strip()
+            aff = author.get("affiliation")
+            if isinstance(aff, list):
+                suffix = ",".join(str(item) for item in aff)
+            elif aff is None:
+                suffix = ""
+            else:
+                suffix = str(aff)
+            marker = "*" if author.get("corresponding") else ""
+            items.append(f"{name}$^{{{suffix}{marker}}}$" if suffix or marker else name)
+        else:
+            items.append(str(author))
+    return ", ".join(item for item in items if item)
+
+
+def format_affiliation_meta(frontmatter: dict) -> str:
+    affiliations = frontmatter.get("affiliations") or {}
+    if not isinstance(affiliations, dict):
+        return str(affiliations)
+    lines = []
+    for key, value in affiliations.items():
+        lines.append(f"$^{{{key}}}$ {value}")
+    return r" \\ ".join(lines)
+
+
+def format_keywords(frontmatter: dict) -> str:
+    keywords = frontmatter.get("keywords") or []
+    if isinstance(keywords, list):
+        return "; ".join(str(item) for item in keywords)
+    return str(keywords)
+
+
+def short_author_list(frontmatter: dict) -> str:
+    authors = frontmatter.get("authors") or []
+    if not isinstance(authors, list) or not authors:
+        return ""
+    first = authors[0]
+    if isinstance(first, dict):
+        first_name = str(first.get("name") or "")
+    else:
+        first_name = str(first)
+    if len(authors) == 1:
+        return first_name
+    return f"{first_name} et al."
+
+
+def template_variables(frontmatter: dict, publisher_name: str, publisher: dict, detected_locale: str, mode: str) -> dict[str, str]:
+    latex_cfg = publisher["latex"]
+    cjk_cfg = latex_cfg.get("cjk") or {}
+    body_font = ((publisher.get("docx") or {}).get("font") or {}).get("body") or {}
+    title = str(frontmatter.get("title") or "")
+    return {
+        "title": title,
+        "author-meta": format_author_meta(frontmatter),
+        "affiliation-meta": format_affiliation_meta(frontmatter),
+        "abstract": str(frontmatter.get("abstract") or ""),
+        "keywords-meta": format_keywords(frontmatter),
+        "corresponding-email": str(frontmatter.get("corresponding_email") or ""),
+        "short-title": title[:80],
+        "author-list-short": short_author_list(frontmatter),
+        "documentclass": str(latex_cfg.get("documentclass") or "article"),
+        "classoptions": ",".join(str(item) for item in latex_cfg.get("classoptions") or []),
+        "mainfont": str(body_font.get("family") or "Times New Roman"),
+        "cjk-main-font": str(cjk_cfg.get("main_font") or "Pretendard"),
+        "publisher-name": publisher_name,
+        "detected-locale": detected_locale,
+        "mode": mode,
+        "has-cjk": "true" if detected_locale in {"ko", "mixed"} else "false",
+    }
+
+
+def build_pandoc_command(md_path: Path, out_path: Path, template_path: Path, variables: dict[str, str]) -> list[str]:
+    command = [
+        "pandoc",
+        str(md_path),
+        "--standalone",
+        "--from",
+        "markdown",
+        "--to",
+        "latex",
+        "--template",
+        str(template_path),
+        "--output",
+        str(out_path),
+    ]
+    for key, value in variables.items():
+        if value:
+            command.extend(["-V", f"{key}={value}"])
+    return command
+
+
+def render_markdown_to_latex(
+    md_path: Path,
+    tex_path: Path,
+    publisher_name: str,
+    registry_path: Path,
+    locale: str = "auto",
+    mode: str = "submission",
+) -> str:
+    ensure_pandoc()
+    publisher = load_publisher(registry_path, publisher_name)
+    frontmatter, body, detected_locale = preprocess_markdown(md_path, publisher, locale)
+    script_dir = Path(__file__).resolve().parent
+    template_path = script_dir.parent / publisher["latex"]["pandoc_template"]
+    if not template_path.exists():
+        raise SystemExit(f"Error: LaTeX template not found: {template_path}")
+    tex_path.parent.mkdir(parents=True, exist_ok=True)
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tmp_md = Path(tmpdir) / "input.md"
+        tmp_md.write_text(body, encoding="utf-8")
+        result = run_checked(
+            build_pandoc_command(tmp_md, tex_path, template_path, template_variables(frontmatter, publisher_name, publisher, detected_locale, mode))
+        )
+        if result.returncode != 0:
+            raise SystemExit(result.stdout + result.stderr)
+    return detected_locale
+
+
+def kpsewhich_has(target: str) -> bool:
+    result = run_checked(["kpsewhich", target])
+    return result.returncode == 0 and bool(result.stdout.strip())
+
+
+def preflight_pdf_compile(publisher_name: str, publisher: dict, detected_locale: str) -> None:
+    ensure_pandoc()
+    if not command_path("xelatex"):
+        raise SystemExit(
+            "Error: xelatex not found. TeX Live is required for PDF output. "
+            "Install TeX Live with elsarticle, achemso, IEEEtran, sn-jnl, oblivoir, xeCJK, and latexmk."
+        )
+    if not command_path("kpsewhich"):
+        raise SystemExit(
+            "Error: kpsewhich not found. Install TeX Live so the script can verify required class files before compilation."
+        )
+    documentclass = str(publisher["latex"].get("documentclass") or "")
+    class_file = f"{documentclass}.cls"
+    if not kpsewhich_has(class_file):
+        raise SystemExit(
+            f"Error: required LaTeX class not found: {class_file}. Install the matching TeX Live package for publisher '{publisher_name}'."
+        )
+    if detected_locale in {"ko", "mixed"} and not kpsewhich_has("xeCJK.sty"):
+        raise SystemExit(
+            "Error: xeCJK.sty not found. Korean/CJK PDF output requires xeCJK from TeX Live."
+        )
+
+
+def compile_latex_to_pdf(tex_path: Path, pdf_path: Path) -> str:
+    result = run_checked(
+        ["xelatex", "-interaction=nonstopmode", "-halt-on-error", tex_path.name],
+        workdir=tex_path.parent,
+    )
+    built_pdf = tex_path.with_suffix(".pdf")
+    if result.returncode != 0 or not built_pdf.exists():
+        raise SystemExit(result.stdout + result.stderr)
+    pdf_path.parent.mkdir(parents=True, exist_ok=True)
+    pdf_path.write_bytes(built_pdf.read_bytes())
+    return result.stdout + result.stderr
+
+
+def convert_md_to_pdf(
+    md_path: Path,
+    pdf_path: Path,
+    publisher_name: str,
+    registry_path: Path,
+    locale: str = "auto",
+    mode: str = "submission",
+) -> str:
+    publisher = load_publisher(registry_path, publisher_name)
+    _, _, detected_locale = preprocess_markdown(md_path, publisher, locale)
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tmp_tex = Path(tmpdir) / f"{publisher_name}.tex"
+        render_markdown_to_latex(md_path, tmp_tex, publisher_name, registry_path, locale, mode)
+        if mode == "draft":
+            draft_tex = pdf_path.with_suffix(".tex")
+            draft_tex.parent.mkdir(parents=True, exist_ok=True)
+            draft_tex.write_text(tmp_tex.read_text(encoding="utf-8"), encoding="utf-8")
+        preflight_pdf_compile(publisher_name, publisher, detected_locale)
+        log = compile_latex_to_pdf(tmp_tex, pdf_path)
+    return log
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Convert Markdown to PDF via pandoc and XeLaTeX")
+    parser.add_argument("input", help="Input Markdown file")
+    parser.add_argument("output", help="Output PDF file")
+    parser.add_argument("--publisher", required=True, help="Publisher profile from templates/registry.yaml")
+    parser.add_argument("--registry", default=None, help="Path to templates/registry.yaml")
+    parser.add_argument("--locale", choices=("auto", "en", "ko", "mixed"), default="auto")
+    parser.add_argument("--submission", action="store_true")
+    parser.add_argument("--draft", action="store_true")
+    args = parser.parse_args()
+    if args.submission and args.draft:
+        parser.error("--submission and --draft are mutually exclusive")
+    return args
+
+
+def main() -> int:
+    args = parse_args()
+    script_dir = Path(__file__).resolve().parent
+    md_path = Path(args.input).expanduser().resolve()
+    pdf_path = Path(args.output).expanduser().resolve()
+    registry_path = Path(args.registry).expanduser().resolve() if args.registry else script_dir.parent / "templates" / "registry.yaml"
+    if not md_path.exists():
+        print(f"Error: Input file not found: {md_path}")
+        return 1
+    mode = "draft" if args.draft else "submission"
+    try:
+        log = convert_md_to_pdf(md_path, pdf_path, args.publisher, registry_path, args.locale, mode)
+    except SystemExit as exc:
+        print(str(exc), file=sys.stderr)
+        return 1
+    print(f"Successfully converted {md_path} to {pdf_path} [publisher={args.publisher}, mode={mode}]")
+    if log.strip():
+        print(log)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/assets/lithermes-plugin/skills/lit-docx/scripts/convert_pdf.py

@@ -0,0 +1,130 @@
+import sys
+import fitz  # PyMuPDF
+import re
+
+def clean_text(text):
+    """
+    Cleans up common PDF extraction artifacts.
+    """
+    # Replace non-breaking spaces with regular spaces
+    text = text.replace('\xa0', ' ')
+
+    # Remove excessive whitespace
+    text = re.sub(r'[ \t]+', ' ', text)
+
+    # Remove common journal header/footer noise (simple heuristics)
+    # Example: "Journal Pre-proof", PAGE numbers alone, DOIs repeated at edges
+    lines = text.split('\n')
+    cleaned_lines = []
+
+    for line in lines:
+        stripped = line.strip()
+        # Skip empty lines
+        if not stripped:
+            continue
+
+        # Skip page numbers (just digits)
+        if re.match(r'^\d+$', stripped):
+            continue
+
+        # Example heuristic: Skip lines that look like standard journal headers
+        if stripped.lower() in ["journal pre-proof", "accepted manuscript"]:
+            continue
+
+        cleaned_lines.append(line)
+
+    return "\n".join(cleaned_lines)
+
+def merge_paragraphs(text_blocks):
+    """
+    Merges text blocks into coherent paragraphs.
+    PDFs often break lines; we need to reassemble them.
+    text_blocks is a list of strings, each representing a block of text.
+    """
+    full_text = ""
+    for block in text_blocks:
+        # Clean the block first
+        block = block.strip()
+        if not block:
+            continue
+
+        # Split block into lines to process internal line breaks
+        lines = block.split('\n')
+        merged_block = ""
+
+        for i, line in enumerate(lines):
+            line = line.strip()
+            if not line:
+                continue
+
+            if not merged_block:
+                merged_block = line
+            else:
+                # specific check for hyphenation
+                if merged_block.endswith('-'):
+                    # Remove hyphen and join (e.g. "for- \n mation" -> "formation")
+                    merged_block = merged_block[:-1] + line
+                else:
+                    # If the previous line ends with a sentence ender, usually keep separate or add space?
+                    # In standard paragraphs, just add space.
+                    merged_block += " " + line
+
+        full_text += merged_block + "\n\n"
+
+    return full_text
+
+def convert_pdf_to_md(pdf_path, md_path):
+    doc = fitz.open(pdf_path)
+    output_text = []
+
+    for page_num, page in enumerate(doc):
+        # get_text("blocks") returns a list of items like:
+        # (x0, y0, x1, y1, "text", block_no, block_type)
+        # sort=True sorts by top-left to bottom-right, handling columns effectively.
+        blocks = page.get_text("blocks", sort=True)
+
+        page_content = []
+
+        # Exclude header/footer area by coordinate
+        page_height = page.rect.height
+        margin_top = page_height * 0.05  # Top 5%
+        margin_bottom = page_height * 0.95 # Bottom 5% checks
+
+        for b in blocks:
+            # Block structure: (x0, y0, x1, y1, text, block_no, block_type)
+            if b[6] == 0:  # text block
+                y0 = b[1]
+                y1 = b[3]
+                text = b[4]
+
+                # Simple filter for obvious header/footers based on position
+                if y1 < margin_top or y0 > margin_bottom:
+                     continue
+
+                page_content.append(text)
+
+        # Process the page's blocks
+        merged_page_text = merge_paragraphs(page_content)
+        cleaned_page_text = clean_text(merged_page_text)
+
+        output_text.append(cleaned_page_text)
+
+        # Add a visual separator between pages (optional, but helpful for debugging context)
+        # output_text.append(f"\n<!-- Page {page_num + 1} -->\n")
+
+    full_text = "\n".join(output_text)
+
+    with open(md_path, "w", encoding="utf-8") as f:
+        f.write(full_text)
+
+    print(f"Successfully converted {pdf_path} to {md_path}")
+
+if __name__ == "__main__":
+    if len(sys.argv) < 3:
+        print("Usage: python convert_pdf.py <input.pdf> <output.md>")
+        sys.exit(1)
+
+    pdf_file = sys.argv[1]
+    md_file = sys.argv[2]
+
+    convert_pdf_to_md(pdf_file, md_file)

package/assets/lithermes-plugin/skills/lit-docx/scripts/edit_docx.py

@@ -0,0 +1,297 @@
+#!/usr/bin/env python3
+"""Edit existing DOCX files with common operations.
+
+Usage:
+    # Find and replace text
+    python edit_docx.py input.docx --replace "OLD" "NEW" -o output.docx
+
+    # Append markdown content
+    python edit_docx.py input.docx --append-md content.md -o output.docx
+
+    # Insert at placeholder
+    python edit_docx.py input.docx --insert-at "{{MARKER}}" "New content" -o output.docx
+
+    # Extract text
+    python edit_docx.py input.docx --extract-text
+
+    # Show document structure
+    python edit_docx.py input.docx --show-structure
+
+Features:
+- Find & Replace across paragraphs, tables, headers, footers
+- Append content from Markdown file
+- Insert content at placeholder markers
+- Extract all text for inspection
+- Show document structure (headings)
+"""
+
+from __future__ import annotations
+import argparse
+import re
+import sys
+from pathlib import Path
+
+try:
+    from docx import Document
+    from docx.shared import Pt
+except ImportError:
+    print("Error: 'python-docx' library not found. Install with: pip install python-docx")
+    sys.exit(1)
+
+
+def find_and_replace(doc: Document, old_text: str, new_text: str, case_sensitive: bool = True) -> int:
+    """Find and replace text in all document elements. Returns count of replacements."""
+    count = 0
+    flags = 0 if case_sensitive else re.IGNORECASE
+    pattern = re.compile(re.escape(old_text), flags)
+
+    def replace_in_paragraph(paragraph):
+        nonlocal count
+        full_text = paragraph.text
+        if pattern.search(full_text):
+            # Count matches
+            matches = len(pattern.findall(full_text))
+            count += matches
+
+            # Simple approach: reconstruct paragraph
+            new_full_text = pattern.sub(new_text, full_text)
+
+            # Clear existing runs and add new text
+            # Note: This loses formatting. For format-preserving, need more complex logic.
+            for run in paragraph.runs:
+                run.text = ""
+            if paragraph.runs:
+                paragraph.runs[0].text = new_full_text
+            else:
+                paragraph.add_run(new_full_text)
+
+    # Process main body paragraphs
+    for para in doc.paragraphs:
+        replace_in_paragraph(para)
+
+    # Process tables
+    for table in doc.tables:
+        for row in table.rows:
+            for cell in row.cells:
+                for para in cell.paragraphs:
+                    replace_in_paragraph(para)
+
+    # Process headers and footers
+    for section in doc.sections:
+        for header in [section.header, section.first_page_header, section.even_page_header]:
+            if header:
+                for para in header.paragraphs:
+                    replace_in_paragraph(para)
+        for footer in [section.footer, section.first_page_footer, section.even_page_footer]:
+            if footer:
+                for para in footer.paragraphs:
+                    replace_in_paragraph(para)
+
+    return count
+
+
+def insert_at_marker(doc: Document, marker: str, content: str) -> bool:
+    """Insert content at a placeholder marker. Returns True if marker found."""
+    found = False
+
+    for para in doc.paragraphs:
+        if marker in para.text:
+            # Replace marker with content
+            for run in para.runs:
+                if marker in run.text:
+                    run.text = run.text.replace(marker, content)
+                    found = True
+
+    # Also check tables
+    for table in doc.tables:
+        for row in table.rows:
+            for cell in row.cells:
+                for para in cell.paragraphs:
+                    if marker in para.text:
+                        for run in para.runs:
+                            if marker in run.text:
+                                run.text = run.text.replace(marker, content)
+                                found = True
+
+    return found
+
+
+def append_markdown_content(doc: Document, md_path: Path):
+    """Append content from a Markdown file to the document."""
+    # Import the converter
+    script_dir = Path(__file__).parent
+    sys.path.insert(0, str(script_dir))
+
+    try:
+        from convert_md_to_docx import convert_md_to_docx, html_to_docx
+        import markdown
+    except ImportError as e:
+        print(f"Error importing converter: {e}")
+        print("Make sure convert_md_to_docx.py is in the same directory")
+        return False
+
+    # Read and convert markdown
+    md_text = md_path.read_text(encoding='utf-8')
+    md_converter = markdown.Markdown(extensions=[
+        'tables',
+        'fenced_code',
+        'nl2br',
+        'sane_lists',
+    ])
+    html = md_converter.convert(md_text)
+
+    # Add a separator
+    doc.add_paragraph()
+    doc.add_paragraph('─' * 50)
+    doc.add_paragraph()
+
+    # Convert and append HTML content
+    html_to_docx(html, doc, md_path)
+
+    return True
+
+
+def extract_text(doc: Document) -> str:
+    """Extract all text from document."""
+    lines = []
+
+    for para in doc.paragraphs:
+        lines.append(para.text)
+
+    for table in doc.tables:
+        lines.append("\n[TABLE]")
+        for row in table.rows:
+            cells = [cell.text for cell in row.cells]
+            lines.append(" | ".join(cells))
+        lines.append("[/TABLE]\n")
+
+    return "\n".join(lines)
+
+
+def show_structure(doc: Document) -> str:
+    """Show document structure (headings and paragraphs)."""
+    lines = []
+
+    for i, para in enumerate(doc.paragraphs):
+        style_name = para.style.name if para.style else "Normal"
+        text_preview = para.text[:60] + "..." if len(para.text) > 60 else para.text
+
+        if "Heading" in style_name:
+            level = style_name.replace("Heading ", "")
+            indent = "  " * (int(level) - 1) if level.isdigit() else ""
+            lines.append(f"{indent}[{style_name}] {text_preview}")
+        elif para.text.strip():
+            lines.append(f"  [{style_name}] {text_preview}")
+
+    # Count tables
+    table_count = len(doc.tables)
+    if table_count:
+        lines.append(f"\n[{table_count} table(s) in document]")
+
+    return "\n".join(lines)
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Edit existing DOCX files with common operations"
+    )
+    parser.add_argument("input", help="Input DOCX file")
+    parser.add_argument("-o", "--output", help="Output DOCX file (required for modifications)")
+
+    # Operations (mutually exclusive)
+    ops = parser.add_mutually_exclusive_group(required=True)
+    ops.add_argument(
+        "--replace",
+        nargs=2,
+        metavar=("OLD", "NEW"),
+        help="Find and replace text"
+    )
+    ops.add_argument(
+        "--append-md",
+        metavar="MD_FILE",
+        help="Append content from Markdown file"
+    )
+    ops.add_argument(
+        "--insert-at",
+        nargs=2,
+        metavar=("MARKER", "CONTENT"),
+        help="Insert content at placeholder marker"
+    )
+    ops.add_argument(
+        "--extract-text",
+        action="store_true",
+        help="Extract all text from document"
+    )
+    ops.add_argument(
+        "--show-structure",
+        action="store_true",
+        help="Show document structure (headings)"
+    )
+
+    # Options
+    parser.add_argument(
+        "--case-insensitive",
+        action="store_true",
+        help="Case-insensitive search for --replace"
+    )
+
+    return parser.parse_args()
+
+
+def main() -> int:
+    args = parse_args()
+
+    input_path = Path(args.input).expanduser().resolve()
+    if not input_path.exists():
+        print(f"Error: Input file not found: {input_path}")
+        return 1
+
+    doc = Document(str(input_path))
+
+    # Read-only operations
+    if args.extract_text:
+        print(extract_text(doc))
+        return 0
+
+    if args.show_structure:
+        print(show_structure(doc))
+        return 0
+
+    # Modification operations require output
+    if not args.output:
+        print("Error: --output/-o is required for modification operations")
+        return 1
+
+    output_path = Path(args.output).expanduser().resolve()
+
+    if args.replace:
+        old_text, new_text = args.replace
+        count = find_and_replace(doc, old_text, new_text, not args.case_insensitive)
+        print(f"Replaced {count} occurrence(s) of '{old_text}' with '{new_text}'")
+
+    elif args.append_md:
+        md_path = Path(args.append_md).expanduser().resolve()
+        if not md_path.exists():
+            print(f"Error: Markdown file not found: {md_path}")
+            return 1
+        if append_markdown_content(doc, md_path):
+            print(f"Appended content from {md_path}")
+        else:
+            print("Error appending content")
+            return 1
+
+    elif args.insert_at:
+        marker, content = args.insert_at
+        if insert_at_marker(doc, marker, content):
+            print(f"Inserted content at marker '{marker}'")
+        else:
+            print(f"Warning: Marker '{marker}' not found in document")
+
+    # Save modified document
+    doc.save(str(output_path))
+    print(f"Saved to {output_path}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())