@joaodotwork/md-2-pdf 1.0.0

package/README.md

@@ -0,0 +1,95 @@
+# Markdown to PDF Converter with Mermaid Support
+
+A Python utility to convert Markdown files to PDF while properly rendering Mermaid diagrams.
+
+## Features
+
+- Converts Markdown files to PDF
+- Properly renders Mermaid diagrams as images in the PDF
+- Processes individual files or entire directories
+- Customizable output and temporary directories
+
+## Requirements
+
+- Python 3.6+
+- Node.js and npm (for Mermaid CLI)
+- Pandoc (for Markdown to PDF conversion)
+- LaTeX (XeLaTeX for PDF generation)
+
+## Installation
+
+1. Ensure you have Python 3.6+ installed
+2. Install Node.js and npm
+3. Install Pandoc: https://pandoc.org/installing.html
+4. Install a LaTeX distribution like TeX Live or MiKTeX
+5. Clone this repository or download the script
+
+The script will automatically install the Mermaid CLI (@mermaid-js/mermaid-cli) if needed.
+
+## Usage
+
+### Basic Usage
+
+Convert a single Markdown file to PDF:
+
+```bash
+python md_to_pdf.py path/to/file.md
+```
+
+Convert all Markdown files in a directory:
+
+```bash
+python md_to_pdf.py path/to/directory
+```
+
+### Advanced Options
+
+Specify output file or directory:
+
+```bash
+python md_to_pdf.py path/to/input.md -o path/to/output.pdf
+python md_to_pdf.py path/to/input_dir -o path/to/output_dir
+```
+
+Specify custom temporary directory:
+
+```bash
+python md_to_pdf.py path/to/input.md -t path/to/temp_dir
+```
+
+Check if all dependencies are installed:
+
+```bash
+python md_to_pdf.py --check-only
+```
+
+## How It Works
+
+1. The script reads the Markdown file and extracts Mermaid diagram code blocks
+2. For each Mermaid diagram, it:
+   - Saves the diagram code to a temporary file
+   - Uses Mermaid CLI to render the diagram as an image
+   - Replaces the Mermaid code block with an image reference
+3. The modified Markdown with image references is saved to a temporary file
+4. Pandoc converts the modified Markdown to PDF using XeLaTeX
+
+## Example
+
+Input Markdown:
+
+````markdown
+# Sample Document
+
+Here's a diagram:
+
+```mermaid
+flowchart TD
+    A[Start] --> B{Decision}
+    B -->|Yes| C[Process 1]
+    B -->|No| D[Process 2]
+    C --> E[End]
+    D --> E
+```
+````
+
+This will be converted to a PDF with the diagram properly rendered.

package/bin/index.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+const path = require('path');
+
+// Path to the python script
+const scriptPath = path.join(__dirname, '../md_to_pdf.py');
+
+// Forward all arguments passed to this script
+const args = [scriptPath, ...process.argv.slice(2)];
+
+// Spawn the python process
+// We use 'inherit' to preserve colors and output streaming
+const pythonProcess = spawn('python3', args, { stdio: 'inherit' });
+
+pythonProcess.on('error', (err) => {
+  console.error('Failed to start python process:', err);
+  console.error('Make sure python3 is installed and available in your PATH.');
+  process.exit(1);
+});
+
+pythonProcess.on('close', (code) => {
+  process.exit(code);
+});

package/md_to_pdf.py

@@ -0,0 +1,295 @@
+#!/usr/bin/env python3
+"""
+Markdown to PDF converter with Mermaid diagram support
+
+This script converts markdown files to PDF while properly rendering Mermaid diagrams.
+"""
+
+import argparse
+import os
+import re
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import List, Optional, Tuple
+
+
+def find_mermaid_blocks(markdown_content: str) -> List[Tuple[str, str]]:
+    """Extract mermaid blocks from markdown content.
+    
+    Returns a list of tuples, each containing:
+    - The full match (including ```mermaid delimiters)
+    - The mermaid diagram code only
+    """
+    pattern = r"```mermaid\n(.*?)```"
+    matches = re.finditer(pattern, markdown_content, re.DOTALL)
+    return [(match.group(0), match.group(1).strip()) for match in matches]
+
+
+def render_mermaid_diagram(mermaid_code: str, output_path: str) -> bool:
+    """Render a mermaid diagram to an image file using mmdc CLI.
+    
+    Args:
+        mermaid_code: The mermaid diagram code
+        output_path: Path to save the rendered image
+        
+    Returns:
+        True if successful, False otherwise
+    """
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.mmd', delete=False) as temp_file:
+        temp_file_path = temp_file.name
+        temp_file.write(mermaid_code)
+    
+    # Try local node_modules first, then global mmdc
+    mmdc_path = os.path.join(os.getcwd(), 'node_modules', '.bin', 'mmdc')
+    if not os.path.exists(mmdc_path):
+        mmdc_path = 'mmdc'
+    
+    try:
+        subprocess.run([
+            mmdc_path,
+            '-i', temp_file_path,
+            '-o', output_path,
+            '-b', 'transparent'
+        ], check=True, capture_output=True)
+        return True
+    except (subprocess.CalledProcessError, FileNotFoundError) as e:
+        print(f"Error rendering mermaid diagram: {e}")
+        if hasattr(e, 'stdout'):
+            print(f"stdout: {e.stdout.decode()}")
+        if hasattr(e, 'stderr'):
+            print(f"stderr: {e.stderr.decode()}")
+        return False
+    finally:
+        os.unlink(temp_file_path)
+
+
+def replace_mermaid_with_images(
+    markdown_content: str,
+    mermaid_blocks: List[Tuple[str, str]],
+    output_dir: str,
+    base_filename: str
+) -> str:
+    """Replace mermaid code blocks with image references in the markdown.
+    
+    Args:
+        markdown_content: The original markdown content
+        mermaid_blocks: List of mermaid blocks extracted from the content
+        output_dir: Directory to save rendered images
+        base_filename: Base name for generated image files
+        
+    Returns:
+        Updated markdown content with image references
+    """
+    updated_content = markdown_content
+    
+    for i, (full_match, mermaid_code) in enumerate(mermaid_blocks):
+        image_filename = f"{base_filename}_diagram_{i}.png"
+        image_path = os.path.join(output_dir, image_filename)
+        
+        if render_mermaid_diagram(mermaid_code, image_path):
+            # Replace the mermaid block with an image reference
+            image_ref = f"\n\n![Diagram {i+1}]({image_path})\n\n"
+            updated_content = updated_content.replace(full_match, image_ref)
+    
+    return updated_content
+
+
+def convert_markdown_to_pdf(
+    input_path: str,
+    output_path: Optional[str] = None,
+    temp_dir: Optional[str] = None
+) -> bool:
+    """Convert a markdown file to PDF, rendering any mermaid diagrams.
+    
+    Args:
+        input_path: Path to the input markdown file
+        output_path: Path for the output PDF file (optional)
+        temp_dir: Directory to store temporary files (optional)
+        
+    Returns:
+        True if conversion was successful, False otherwise
+    """
+    input_file = Path(input_path)
+    
+    # Determine output path if not provided
+    if not output_path:
+        output_path = str(input_file.with_suffix('.pdf'))
+    
+    # Create temp directory if not provided
+    if not temp_dir:
+        temp_dir = tempfile.mkdtemp()
+    else:
+        os.makedirs(temp_dir, exist_ok=True)
+    
+    # Read the markdown content
+    with open(input_path, 'r') as f:
+        content = f.read()
+    
+    # Find and extract mermaid blocks
+    mermaid_blocks = find_mermaid_blocks(content)
+    
+    if mermaid_blocks:
+        # Replace mermaid blocks with image references
+        base_filename = input_file.stem
+        updated_content = replace_mermaid_with_images(content, mermaid_blocks, temp_dir, base_filename)
+        
+        # Write updated markdown to temporary file
+        temp_md_path = os.path.join(temp_dir, f"{base_filename}_processed.md")
+        with open(temp_md_path, 'w') as f:
+            f.write(updated_content)
+        
+        input_for_pandoc = temp_md_path
+    else:
+        input_for_pandoc = input_path
+    
+    # Determine available PDF engine
+    pdf_engine = 'xelatex'
+    try:
+        subprocess.run(['which', 'xelatex'], check=True, capture_output=True)
+    except subprocess.CalledProcessError:
+        try:
+            subprocess.run(['which', 'pdflatex'], check=True, capture_output=True)
+            pdf_engine = 'pdflatex'
+        except subprocess.CalledProcessError:
+            try:
+                subprocess.run(['which', 'weasyprint'], check=True, capture_output=True)
+                pdf_engine = 'weasyprint'
+            except subprocess.CalledProcessError:
+                try:
+                    subprocess.run(['which', 'wkhtmltopdf'], check=True, capture_output=True)
+                    pdf_engine = 'wkhtmltopdf'
+                except subprocess.CalledProcessError:
+                    print("No suitable PDF engine found (xelatex, pdflatex, weasyprint, wkhtmltopdf).")
+                    return False
+
+    print(f"Using PDF engine: {pdf_engine}")
+
+    # Convert to PDF using pandoc
+    try:
+        subprocess.run([
+            'pandoc',
+            input_for_pandoc,
+            '-o', output_path,
+            f'--pdf-engine={pdf_engine}',
+            '-V', 'geometry:margin=1in'
+        ], check=True, capture_output=True)
+        print(f"Successfully converted {input_path} to {output_path}")
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"Error converting markdown to PDF: {e}")
+        print(f"stdout: {e.stdout.decode()}")
+        print(f"stderr: {e.stderr.decode()}")
+        return False
+
+
+def process_directory(
+    input_dir: str,
+    output_dir: Optional[str] = None,
+    temp_dir: Optional[str] = None
+) -> None:
+    """Process all markdown files in a directory.
+    
+    Args:
+        input_dir: Directory containing markdown files
+        output_dir: Directory to save PDF files (optional)
+        temp_dir: Directory to store temporary files (optional)
+    """
+    input_dir_path = Path(input_dir)
+    
+    # Determine output directory
+    if not output_dir:
+        output_dir = str(input_dir_path)
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # Create temp directory if not provided
+    if not temp_dir:
+        temp_dir = tempfile.mkdtemp()
+    else:
+        os.makedirs(temp_dir, exist_ok=True)
+    
+    # Process each markdown file
+    for md_file in input_dir_path.glob('*.md'):
+        output_path = os.path.join(output_dir, f"{md_file.stem}.pdf")
+        convert_markdown_to_pdf(str(md_file), output_path, temp_dir)
+
+
+def check_dependencies() -> bool:
+    """Check if required dependencies are installed.
+    
+    Returns:
+        True if all dependencies are available, False otherwise
+    """
+    dependencies = ['npx', 'pandoc']
+    
+    for dep in dependencies:
+        try:
+            subprocess.run(['which', dep], check=True, capture_output=True)
+        except subprocess.CalledProcessError:
+            print(f"Required dependency not found: {dep}")
+            if dep == 'npx':
+                print("Please install Node.js and npm")
+            elif dep == 'pandoc':
+                print("Please install pandoc")
+            return False
+    
+    # Check for mermaid-cli
+    try:
+        subprocess.run(
+            ['mmdc', '--version'],
+            check=True, capture_output=True
+        )
+    except subprocess.CalledProcessError:
+        print("Mermaid CLI not found, installing...")
+        try:
+            subprocess.run(['npm', 'install', '-g', '@mermaid-js/mermaid-cli'], check=True)
+        except subprocess.CalledProcessError:
+            print("Failed to install @mermaid-js/mermaid-cli")
+            return False
+    
+    return True
+
+
+def main() -> None:
+    """Main entry point for the script."""
+    parser = argparse.ArgumentParser(
+        description='Convert markdown files to PDF with mermaid diagram support'
+    )
+    parser.add_argument('input', help='Input markdown file or directory')
+    parser.add_argument(
+        '-o', '--output',
+        help='Output PDF file (for single file) or directory (for directory input)'
+    )
+    parser.add_argument(
+        '-t', '--temp-dir',
+        help='Directory to store temporary files'
+    )
+    parser.add_argument(
+        '--check-only',
+        action='store_true',
+        help='Only check dependencies without converting'
+    )
+    
+    args = parser.parse_args()
+    
+    # Check dependencies
+    if not check_dependencies():
+        print("Missing dependencies. Please install the required tools.")
+        return
+    
+    if args.check_only:
+        print("All dependencies are installed correctly.")
+        return
+    
+    # Process input
+    input_path = Path(args.input)
+    if input_path.is_dir():
+        process_directory(args.input, args.output, args.temp_dir)
+    elif input_path.is_file():
+        convert_markdown_to_pdf(args.input, args.output, args.temp_dir)
+    else:
+        print(f"Input path does not exist: {args.input}")
+
+
+if __name__ == "__main__":
+    main()

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@joaodotwork/md-2-pdf",
+  "version": "1.0.0",
+  "description": "Convert markdown files to PDF with mermaid diagram support",
+  "main": "index.js",
+  "bin": {
+    "md-2-pdf": "./bin/index.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "markdown",
+    "pdf",
+    "mermaid",
+    "converter"
+  ],
+  "author": "Joao",
+  "license": "ISC",
+  "dependencies": {
+    "@mermaid-js/mermaid-cli": "^11.4.2"
+  },
+  "files": [
+    "md_to_pdf.py",
+    "bin/",
+    "requirements.txt"
+  ]
+}

package/requirements.txt

@@ -0,0 +1,21 @@
+# Python dependencies for md_to_pdf.py
+
+# External Python packages
+PyPDF2>=3.0.0
+Pillow>=10.0.0
+markdown>=3.4.0
+weasyprint>=60.0.0
+
+# External system dependencies (not installed via pip):
+# - pandoc: sudo apt-get install pandoc
+# - texlive-xetex: sudo apt-get install texlive-xetex
+# - Node.js/npm: Install from https://nodejs.org/ or via package manager
+# - mermaid-cli: npm install -g @mermaid-js/mermaid-cli
+
+# Installation Steps:
+# 1. Install Python dependencies: pip install -r requirements.txt
+# 2. Install system dependencies:
+#    sudo apt-get update
+#    sudo apt-get install -y pandoc texlive-xetex
+# 3. Install Node.js dependencies:
+#    npm install -g @mermaid-js/mermaid-cli