Create app.py

app.py

@@ -0,0 +1,844 @@
+"""
+MarkdownMuse: A Python application for converting Markdown to beautifully formatted PDFs
+
+This module implements the core functionality needed for the MarkdownMuse application.
+"""
+
+import os
+import re
+import sys
+import glob
+import logging
+from typing import List, Dict, Any, Optional, Tuple
+from bs4 import BeautifulSoup
+import markdown
+from markdown.extensions.tables import TableExtension
+from markdown.extensions.fenced_code import FencedCodeExtension
+from markdown.extensions.toc import TocExtension
+from reportlab.lib.pagesizes import letter, A4
+from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+from reportlab.lib.units import inch
+from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, Image, PageBreak, Preformatted, ListFlowable, ListItem
+from reportlab.lib.colors import HexColor, black, grey
+from reportlab.lib import colors
+from reportlab.lib.enums import TA_LEFT, TA_CENTER, TA_RIGHT
+import html
+import base64
+import requests
+from PIL import Image as PilImage
+import io
+import tempfile
+
+# Set up logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+class MarkdownToPDFConverter:
+    """
+    Class to convert Markdown content to PDF using ReportLab.
+    """
+    def __init__(
+        self, 
+        output_path: str = "output.pdf", 
+        page_size: str = "A4",
+        margins: Tuple[float, float, float, float] = (0.75, 0.75, 0.75, 0.75),
+        font_name: str = "Helvetica",
+        base_font_size: int = 10,
+        heading_scale: Dict[int, float] = None,
+        include_toc: bool = True,
+        code_style: str = "github"
+    ):
+        """
+        Initialize the converter with configuration options.
+        
+        Args:
+            output_path: Path to save the PDF
+            page_size: Page size ("A4" or "letter")
+            margins: Tuple of margins (left, right, top, bottom) in inches
+            font_name: Base font name to use
+            base_font_size: Base font size in points
+            heading_scale: Dictionary of heading levels to font size multipliers
+            include_toc: Whether to include a table of contents
+            code_style: Style to use for code blocks
+        """
+        self.output_path = output_path
+        self.page_size = A4 if page_size.upper() == "A4" else letter
+        self.margins = margins
+        self.font_name = font_name
+        self.base_font_size = base_font_size
+        self.heading_scale = heading_scale or {
+            1: 2.0,   # H1 is 2.0x base font size
+            2: 1.7,   # H2 is 1.7x base font size
+            3: 1.4,   # H3 is 1.4x base font size
+            4: 1.2,   # H4 is 1.2x base font size
+            5: 1.1,   # H5 is 1.1x base font size
+            6: 1.0    # H6 is 1.0x base font size
+        }
+        self.include_toc = include_toc
+        self.code_style = code_style
+        
+        # Initialize styles
+        self.styles = getSampleStyleSheet()
+        self._setup_styles()
+        
+        # Initialize document elements
+        self.elements = []
+        self.toc_entries = []
+    
+    def _setup_styles(self) -> None:
+        """Set up custom paragraph styles for the document."""
+        # Modify existing Normal style
+        self.styles['Normal'].fontName = self.font_name
+        self.styles['Normal'].fontSize = self.base_font_size
+        self.styles['Normal'].leading = self.base_font_size * 1.2
+        self.styles['Normal'].spaceAfter = self.base_font_size * 0.8
+        
+        # Heading styles
+        for level in range(1, 7):
+            size_multiplier = self.heading_scale.get(level, 1.0)
+            heading_name = f'Heading{level}'
+            
+            # Check if the heading style already exists
+            if heading_name in self.styles:
+                # Modify existing style
+                self.styles[heading_name].parent = self.styles['Normal']
+                self.styles[heading_name].fontName = f'{self.font_name}-Bold'
+                self.styles[heading_name].fontSize = int(self.base_font_size * size_multiplier)
+                self.styles[heading_name].leading = int(self.base_font_size * size_multiplier * 1.2)
+                self.styles[heading_name].spaceAfter = self.base_font_size
+                self.styles[heading_name].spaceBefore = self.base_font_size * (1 + (0.2 * (7 - level)))
+            else:
+                # Create new style
+                self.styles.add(
+                    ParagraphStyle(
+                        name=heading_name,
+                        parent=self.styles['Normal'],
+                        fontName=f'{self.font_name}-Bold',
+                        fontSize=int(self.base_font_size * size_multiplier),
+                        leading=int(self.base_font_size * size_multiplier * 1.2),
+                        spaceAfter=self.base_font_size,
+                        spaceBefore=self.base_font_size * (1 + (0.2 * (7 - level))),
+                    )
+                )
+        
+        # Code block style
+        self.styles.add(
+            ParagraphStyle(
+                name='CodeBlock',
+                fontName='Courier',
+                fontSize=self.base_font_size * 0.9,
+                leading=self.base_font_size * 1.1,
+                spaceAfter=self.base_font_size,
+                spaceBefore=self.base_font_size,
+                leftIndent=self.base_font_size,
+                backgroundColor=HexColor('#EEEEEE'),
+                borderWidth=0,
+                borderPadding=self.base_font_size * 0.5,
+            )
+        )
+        
+        # List item style
+        self.styles.add(
+            ParagraphStyle(
+                name='ListItem',
+                parent=self.styles['Normal'],
+                leftIndent=self.base_font_size * 2,
+                firstLineIndent=-self.base_font_size,
+            )
+        )
+        
+        # Table of contents styles
+        self.styles.add(
+            ParagraphStyle(
+                name='TOCHeading',
+                parent=self.styles['Heading1'],
+                fontSize=int(self.base_font_size * 1.5),
+                spaceAfter=self.base_font_size * 1.5,
+            )
+        )
+        
+        for level in range(1, 4):  # Create styles for TOC levels
+            self.styles.add(
+                ParagraphStyle(
+                    name=f'TOC{level}',
+                    parent=self.styles['Normal'],
+                    leftIndent=self.base_font_size * (level - 1) * 2,
+                    fontSize=self.base_font_size - (level - 1),
+                    leading=self.base_font_size * 1.4,
+                )
+            )
+    
+    def convert_file(self, md_file_path: str) -> None:
+        """
+        Convert a single markdown file to PDF.
+        
+        Args:
+            md_file_path: Path to the markdown file
+        """
+        # Read markdown content
+        with open(md_file_path, 'r', encoding='utf-8') as f:
+            md_content = f.read()
+        
+        # Convert markdown to PDF
+        self.convert_content(md_content)
+    
+    def convert_content(self, md_content: str) -> None:
+        """
+        Convert markdown content string to PDF.
+        
+        Args:
+            md_content: Markdown content as a string
+        """
+        # Convert markdown to HTML
+        html_content = self._md_to_html(md_content)
+        
+        # Convert HTML to ReportLab elements
+        self._html_to_elements(html_content)
+        
+        # Generate the PDF
+        self._generate_pdf()
+        
+        logger.info(f"PDF created at {self.output_path}")
+    
+    def convert_multiple_files(self, md_file_paths: List[str], 
+                              merge: bool = True,
+                              separate_toc: bool = False) -> None:
+        """
+        Convert multiple markdown files to PDF.
+        
+        Args:
+            md_file_paths: List of paths to markdown files
+            merge: Whether to merge all files into a single PDF
+            separate_toc: Whether to include a separate TOC for each file
+        """
+        if merge:
+            all_content = []
+            
+            for file_path in md_file_paths:
+                logger.info(f"Processing {file_path}")
+                with open(file_path, 'r', encoding='utf-8') as f:
+                    content = f.read()
+                    
+                # Add file name as heading if more than one file
+                if len(md_file_paths) > 1:
+                    file_name = os.path.splitext(os.path.basename(file_path))[0]
+                    content = f"# {file_name}\n\n{content}"
+                
+                # Add page break between files
+                if all_content:
+                    all_content.append("\n\n<div class='page-break'></div>\n\n")
+                
+                all_content.append(content)
+            
+            combined_content = "\n".join(all_content)
+            self.convert_content(combined_content)
+        else:
+            # Process each file separately
+            for i, file_path in enumerate(md_file_paths):
+                converter = MarkdownToPDFConverter(
+                    output_path=f"{os.path.splitext(file_path)[0]}.pdf",
+                    page_size=self.page_size,
+                    margins=self.margins,
+                    font_name=self.font_name,
+                    base_font_size=self.base_font_size,
+                    heading_scale=self.heading_scale,
+                    include_toc=separate_toc,
+                    code_style=self.code_style
+                )
+                converter.convert_file(file_path)
+    
+    def _md_to_html(self, md_content: str) -> str:
+        """
+        Convert markdown content to HTML.
+        
+        Args:
+            md_content: Markdown content
+            
+        Returns:
+            HTML content
+        """
+        # Define extensions for markdown conversion
+        extensions = [
+            'markdown.extensions.extra',
+            'markdown.extensions.smarty',
+            TableExtension(),
+            FencedCodeExtension(),
+            TocExtension(toc_depth=3) if self.include_toc else None
+        ]
+        
+        # Remove None values
+        extensions = [ext for ext in extensions if ext is not None]
+        
+        # Convert markdown to HTML
+        html_content = markdown.markdown(md_content, extensions=extensions)
+        return html_content
+    
+    def _html_to_elements(self, html_content: str) -> None:
+        """
+        Convert HTML content to ReportLab elements.
+        
+        Args:
+            html_content: HTML content
+        """
+        soup = BeautifulSoup(html_content, 'html.parser')
+        
+        # Process elements
+        for element in soup.children:
+            if element.name:
+                self._process_element(element)
+    
+    def _process_element(self, element: BeautifulSoup) -> None:
+        """
+        Process an HTML element and convert it to ReportLab elements.
+        
+        Args:
+            element: BeautifulSoup element
+        """
+        if element.name in ['h1', 'h2', 'h3', 'h4', 'h5', 'h6']:
+            level = int(element.name[1])
+            text = element.get_text()
+            
+            # Add to TOC
+            if self.include_toc:
+                self.toc_entries.append((level, text))
+            
+            # Create heading paragraph
+            self.elements.append(
+                Paragraph(text, self.styles[f'Heading{level}'])
+            )
+            
+        elif element.name == 'p':
+            text = self._process_inline_elements(element)
+            self.elements.append(
+                Paragraph(text, self.styles['Normal'])
+            )
+            
+        elif element.name == 'pre':
+            code = element.get_text()
+            self.elements.append(
+                Preformatted(code, self.styles['CodeBlock'])
+            )
+            
+        elif element.name == 'img':
+            src = element.get('src', '')
+            alt = element.get('alt', 'Image')
+            
+            # Handle different image sources
+            if src.startswith('http'):
+                # Remote image
+                try:
+                    response = requests.get(src)
+                    img_data = response.content
+                    img_stream = io.BytesIO(img_data)
+                    image = Image(img_stream, width=4*inch, height=3*inch)
+                    
+                    # Try to get actual dimensions
+                    try:
+                        pil_img = PilImage.open(img_stream)
+                        width, height = pil_img.size
+                        aspect = width / height
+                        max_width = 6 * inch
+                        
+                        if width > max_width:
+                            new_width = max_width
+                            new_height = new_width / aspect
+                            image = Image(img_stream, width=new_width, height=new_height)
+                    except:
+                        pass  # Use default size if image can't be processed
+                        
+                    self.elements.append(image)
+                except:
+                    # If image can't be retrieved, add a placeholder
+                    self.elements.append(
+                        Paragraph(f"[Image: {alt}]", self.styles['Normal'])
+                    )
+            elif src.startswith('data:image'):
+                # Base64 encoded image
+                try:
+                    # Extract base64 data
+                    b64_data = src.split(',')[1]
+                    img_data = base64.b64decode(b64_data)
+                    img_stream = io.BytesIO(img_data)
+                    image = Image(img_stream, width=4*inch, height=3*inch)
+                    self.elements.append(image)
+                except:
+                    # If image can't be processed, add a placeholder
+                    self.elements.append(
+                        Paragraph(f"[Image: {alt}]", self.styles['Normal'])
+                    )
+            else:
+                # Local image
+                if os.path.exists(src):
+                    image = Image(src, width=4*inch, height=3*inch)
+                    self.elements.append(image)
+                else:
+                    # If image can't be found, add a placeholder
+                    self.elements.append(
+                        Paragraph(f"[Image: {alt}]", self.styles['Normal'])
+                    )
+            
+        elif element.name == 'ul' or element.name == 'ol':
+            list_items = []
+            bullet_type = 'bullet' if element.name == 'ul' else 'numbered'
+            
+            for item in element.find_all('li', recursive=False):
+                text = self._process_inline_elements(item)
+                list_items.append(
+                    ListItem(
+                        Paragraph(text, self.styles['ListItem']),
+                        leftIndent=20
+                    )
+                )
+            
+            self.elements.append(
+                ListFlowable(
+                    list_items,
+                    bulletType=bullet_type,
+                    start=1 if bullet_type == 'numbered' else None,
+                    bulletFormat='%s.' if bullet_type == 'numbered' else '%s'
+                )
+            )
+            
+        elif element.name == 'table':
+            self._process_table(element)
+            
+        elif element.name == 'div' and 'page-break' in element.get('class', []):
+            self.elements.append(PageBreak())
+            
+        elif element.name == 'hr':
+            self.elements.append(Spacer(1, 0.25*inch))
+            
+        # Process children for complex elements
+        elif element.name in ['div', 'blockquote', 'section', 'article']:
+            for child in element.children:
+                if hasattr(child, 'name') and child.name:
+                    self._process_element(child)
+    
+    def _process_inline_elements(self, element: BeautifulSoup) -> str:
+        """
+        Process inline HTML elements like bold, italic, etc.
+        
+        Args:
+            element: BeautifulSoup element
+            
+        Returns:
+            Formatted text with ReportLab markup
+        """
+        html_str = str(element)
+        
+        # Convert common HTML tags to ReportLab paragraph markup
+        replacements = [
+            (r'<strong>(.*?)</strong>', r'<b>\1</b>'),
+            (r'<b>(.*?)</b>', r'<b>\1</b>'),
+            (r'<em>(.*?)</em>', r'<i>\1</i>'),
+            (r'<i>(.*?)</i>', r'<i>\1</i>'),
+            (r'<code>(.*?)</code>', r'<font name="Courier">\1</font>'),
+            (r'<a href="(.*?)">(.*?)</a>', r'<link href="\1">\2</link>'),
+            (r'<u>(.*?)</u>', r'<u>\1</u>'),
+            (r'<strike>(.*?)</strike>', r'<strike>\1</strike>'),
+            (r'<del>(.*?)</del>', r'<strike>\1</strike>'),
+        ]
+        
+        for pattern, replacement in replacements:
+            html_str = re.sub(pattern, replacement, html_str, flags=re.DOTALL)
+        
+        # Extract text with our ReportLab markup from the modified HTML
+        soup = BeautifulSoup(html_str, 'html.parser')
+        return soup.get_text()
+    
+    def _process_table(self, table_element: BeautifulSoup) -> None:
+        """
+        Process an HTML table into a ReportLab Table.
+        
+        Args:
+            table_element: BeautifulSoup table element
+        """
+        rows = []
+        
+        # Extract header row
+        thead = table_element.find('thead')
+        if thead:
+            header_cells = []
+            for th in thead.find_all(['th']):
+                text = self._process_inline_elements(th)
+                # Create a paragraph with bold text for headers
+                header_cells.append(Paragraph(f"<b>{text}</b>", self.styles['Normal']))
+            rows.append(header_cells)
+        
+        # Extract body rows
+        tbody = table_element.find('tbody') or table_element
+        for tr in tbody.find_all('tr'):
+            if tr.parent.name == 'thead':
+                continue  # Skip header rows already processed
+                
+            row_cells = []
+            for cell in tr.find_all(['td', 'th']):
+                text = self._process_inline_elements(cell)
+                if cell.name == 'th':
+                    # Headers are bold
+                    row_cells.append(Paragraph(f"<b>{text}</b>", self.styles['Normal']))
+                else:
+                    row_cells.append(Paragraph(text, self.styles['Normal']))
+            
+            if row_cells:  # Only add non-empty rows
+                rows.append(row_cells)
+        
+        if rows:
+            # Create table and style
+            col_widths = [None] * len(rows[0])  # Auto width for columns
+            table = Table(rows, colWidths=col_widths)
+            
+            # Add basic grid and header styling
+            style = TableStyle([
+                ('GRID', (0, 0), (-1, -1), 0.5, colors.Color(0.7, 0.7, 0.7)),
+                ('BACKGROUND', (0, 0), (-1, 0), colors.Color(0.8, 0.8, 0.8)),
+                ('TEXTCOLOR', (0, 0), (-1, 0), colors.black),
+                ('ALIGN', (0, 0), (-1, 0), 'CENTER'),
+                ('FONTNAME', (0, 0), (-1, 0), f'{self.font_name}-Bold'),
+                ('BOTTOMPADDING', (0, 0), (-1, 0), 8),
+                ('TOPPADDING', (0, 0), (-1, 0), 8),
+                ('BOTTOMPADDING', (0, 1), (-1, -1), 6),
+                ('TOPPADDING', (0, 1), (-1, -1), 6),
+            ])
+            
+            table.setStyle(style)
+            self.elements.append(table)
+            
+            # Add some space after the table
+            self.elements.append(Spacer(1, 0.1*inch))
+    
+    def _generate_toc(self) -> None:
+        """Generate a table of contents."""
+        if not self.toc_entries:
+            return
+        
+        self.elements.append(Paragraph("Table of Contents", self.styles['TOCHeading']))
+        self.elements.append(Spacer(1, 0.2*inch))
+        
+        for level, text in self.toc_entries:
+            if level <= 3:  # Only include headings up to level 3
+                self.elements.append(
+                    Paragraph(text, self.styles[f'TOC{level}'])
+                )
+        
+        self.elements.append(PageBreak())
+    
+    def _generate_pdf(self) -> None:
+        """Generate the PDF document."""
+        # Create the document
+        doc = SimpleDocTemplate(
+            self.output_path,
+            pagesize=self.page_size,
+            leftMargin=self.margins[0]*inch,
+            rightMargin=self.margins[1]*inch,
+            topMargin=self.margins[2]*inch,
+            bottomMargin=self.margins[3]*inch
+        )
+        
+        # Add TOC if requested
+        if self.include_toc and self.toc_entries:
+            self._generate_toc()
+        
+        # Build the PDF
+        doc.build(self.elements)
+
+
+class MarkdownToPDFAgent:
+    """
+    AI Agent to convert Markdown files to PDF with enhanced formatting.
+    """
+    
+    def __init__(self, llm=None):
+        """
+        Initialize the agent with optional LLM for content enhancement.
+        
+        Args:
+            llm: Optional language model for content enhancement
+        """
+        self.llm = llm
+        self.converter = MarkdownToPDFConverter()
+    
+    def setup_from_openai(self, api_key=None):
+        """
+        Setup agent with OpenAI LLM.
+        
+        Args:
+            api_key: OpenAI API key (will use env var if not provided)
+        """
+        try:
+            from langchain_openai import ChatOpenAI
+            
+            api_key = api_key or os.getenv("OPENAI_API_KEY")
+            if not api_key:
+                logger.warning("No OpenAI API key provided. Agent will run without LLM enhancement.")
+                return False
+            
+            self.llm = ChatOpenAI(
+                model="gpt-4",
+                temperature=0.1,
+                api_key=api_key
+            )
+            return True
+        except ImportError:
+            logger.warning("LangChain OpenAI package not found. Install with 'pip install langchain-openai'")
+            return False
+            
+    def setup_from_gemini(self, api_key=None):
+        """
+        Setup agent with Google Gemini LLM.
+        
+        Args:
+            api_key: Google Gemini API key (will use env var if not provided)
+        """
+        try:
+            from langchain_google_genai import ChatGoogleGenerativeAI
+            
+            api_key = api_key or os.getenv("GOOGLE_API_KEY")
+            if not api_key:
+                logger.warning("No Google API key provided. Agent will run without LLM enhancement.")
+                return False
+            
+            try:
+                # Use the latest Gemini model version
+                self.llm = ChatGoogleGenerativeAI(
+                    model="gemini-1.5-flash",
+                    temperature=0.1,
+                    google_api_key=api_key,
+                    convert_system_message_to_human=True
+                )
+                logger.info("Successfully set up Google Gemini LLM")
+                return True
+            except Exception as e:
+                logger.error(f"Error setting up Google Gemini LLM: {str(e)}")
+                return False
+        except ImportError:
+            logger.warning("LangChain Google Generative AI package not found. Install with 'pip install langchain-google-genai'")
+            return False
+    
+    def enhance_markdown(self, content: str, instructions: str = None) -> str:
+        """
+        Enhance markdown content using LLM if available.
+        
+        Args:
+            content: Original markdown content
+            instructions: Specific enhancement instructions
+            
+        Returns:
+            Enhanced markdown content
+        """
+        if not self.llm:
+            logger.warning("No LLM available for enhancement. Returning original content.")
+            return content
+            
+        default_instructions = """
+        Enhance this markdown content while preserving its structure and meaning.
+        Make the following improvements:
+        1. Fix any grammar or spelling issues
+        2. Improve formatting for better readability
+        3. Ensure proper markdown syntax is used
+        4. Add appropriate section headings if missing
+        5. Keep the content factually identical to the original
+        """
+        
+        instructions = instructions or default_instructions
+        
+        try:
+            # Create a prompt for the LLM
+            prompt = f"{instructions}\n\nOriginal content:\n\n{content}\n\nPlease provide the enhanced markdown content:"
+            
+            # Use the LLM directly with proper error handling
+            try:
+                from langchain.schema import HumanMessage
+                logger.info(f"Using LLM type: {type(self.llm).__name__}")
+                messages = [HumanMessage(content=prompt)]
+                result = self.llm.invoke(messages).content
+                logger.info("Successfully received response from LLM")
+            except Exception as e:
+                logger.error(f"Error invoking LLM: {str(e)}")
+                return content
+            
+            # Clean up the result (extract just the markdown part)
+            result = self._clean_agent_output(result)
+            
+            return result
+        except Exception as e:
+            logger.error(f"Error enhancing markdown: {str(e)}")
+            return content  # Return original content if enhancement fails
+    
+    def _clean_agent_output(self, output: str) -> str:
+        """
+        Clean up agent output to extract just the markdown content.
+        
+        Args:
+            output: Raw agent output
+            
+        Returns:
+            Cleaned markdown content
+        """
+        # Check if the output is wrapped in markdown code blocks
+        md_pattern = r"```(?:markdown|md)?\s*([\s\S]*?)```"
+        match = re.search(md_pattern, output)
+        
+        if match:
+            return match.group(1).strip()
+        
+        # If no markdown blocks found, remove any agent commentary
+        lines = output.split('\n')
+        result_lines = []
+        capture = False
+        
+        for line in lines:
+            if capture or not (line.startswith("I") or line.startswith("Here") or line.startswith("The")):
+                capture = True
+                result_lines.append(line)
+                
+        return '\n'.join(result_lines)
+    
+    def process_file(self, input_path: str, output_path: str = None, enhance: bool = False, 
+                     enhancement_instructions: str = None, page_size: str = "A4") -> str:
+        """
+        Process a single markdown file and convert it to PDF.
+        
+        Args:
+            input_path: Path to input markdown file
+            output_path: Path for output PDF (defaults to input path with .pdf extension)
+            enhance: Whether to enhance the content with LLM
+            enhancement_instructions: Specific instructions for enhancement
+            page_size: Page size for the PDF ("A4" or "letter")
+            
+        Returns:
+            Path to the generated PDF
+        """
+        # Validate input file
+        if not os.path.exists(input_path):
+            logger.error(f"Input file not found: {input_path}")
+            return None
+            
+        # Set default output path if not provided
+        if not output_path:
+            output_path = os.path.splitext(input_path)[0] + ".pdf"
+            
+        # Read markdown content
+        with open(input_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+            
+        # Enhance content if requested
+        if enhance and self.llm:
+            logger.info(f"Enhancing content for {input_path}")
+            content = self.enhance_markdown(content, enhancement_instructions)
+            
+        # Configure converter
+        self.converter = MarkdownToPDFConverter(
+            output_path=output_path,
+            page_size=page_size
+        )
+            
+        # Convert to PDF
+        logger.info(f"Converting {input_path} to PDF")
+        self.converter.convert_content(content)
+        
+        return output_path
+    
+    def process_directory(self, input_dir: str, output_dir: str = None, pattern: str = "*.md",
+                        enhance: bool = False, merge: bool = False,
+                        output_filename: str = "merged_document.pdf", 
+                        page_size: str = "A4") -> List[str]:
+        """
+        Process all markdown files in a directory.
+        
+        Args:
+            input_dir: Path to input directory
+            output_dir: Path to output directory (defaults to input directory)
+            pattern: Glob pattern for markdown files
+            enhance: Whether to enhance content with LLM
+            merge: Whether to merge all files into a single PDF
+            output_filename: Filename for merged PDF
+            page_size: Page size for the PDF ("A4" or "letter")
+            
+        Returns:
+            List of paths to generated PDFs
+        """
+        # Validate input directory
+        if not os.path.isdir(input_dir):
+            logger.error(f"Input directory not found: {input_dir}")
+            return []
+            
+        # Set default output directory if not provided
+        if not output_dir:
+            output_dir = input_dir
+        elif not os.path.exists(output_dir):
+            os.makedirs(output_dir)
+            
+        # Get all markdown files
+        md_files = glob.glob(os.path.join(input_dir, pattern))
+        
+        if not md_files:
+            logger.warning(f"No markdown files found in {input_dir} with pattern {pattern}")
+            return []
+            
+        # Sort files to ensure consistent ordering
+        md_files.sort()
+        
+        if merge:
+            logger.info(f"Merging {len(md_files)} markdown files into a single PDF")
+            
+            # Process each file for enhancement if requested
+            if enhance and self.llm:
+                enhanced_contents = []
+                
+                for md_file in md_files:
+                    logger.info(f"Enhancing content for {md_file}")
+                    with open(md_file, 'r', encoding='utf-8') as f:
+                        content = f.read()
+                    
+                    # Add file name as heading
+                    file_name = os.path.splitext(os.path.basename(md_file))[0]
+                    content = f"# {file_name}\n\n{content}"
+                    
+                    enhanced_content = self.enhance_markdown(content)
+                    enhanced_contents.append(enhanced_content)
+                
+                # Merge enhanced contents with page breaks
+                merged_content = "\n\n<div class='page-break'></div>\n\n".join(enhanced_contents)
+                
+                # Convert merged content
+                output_path = os.path.join(output_dir, output_filename)
+                self.converter = MarkdownToPDFConverter(
+                    output_path=output_path,
+                    page_size=page_size
+                )
+                self.converter.convert_content(merged_content)
+                
+                return [output_path]
+            else:
+                # Merge without enhancement
+                output_path = os.path.join(output_dir, output_filename)
+                self.converter = MarkdownToPDFConverter(
+                    output_path=output_path,
+                    page_size=page_size
+                )
+                self.converter.convert_multiple_files(md_files, merge=True)
+                
+                return [output_path]
+        else:
+            # Process each file individually
+            output_files = []
+            
+            for md_file in md_files:
+                output_filename = os.path.splitext(os.path.basename(md_file))[0] + ".pdf"
+                output_path = os.path.join(output_dir, output_filename)
+                
+                processed_file = self.process_file(
+                    md_file, 
+                    output_path, 
+                    enhance=enhance,
+                    page_size=page_size
+                )
+                
+                if processed_file:
+                    output_files.append(processed_file)
+            
+            return output_files