Markdown to HTML Converter (python, written by Gemini Code Assist)

Gemini Code Assist wrote this python project from the task below. It installed and ran on a clean Ubuntu 22.04 machine as written.

Task given to the agent:

TASK: Markdown to HTML Converter

Write a program that converts Markdown documents to HTML with support for GitHub Flavored Markdown extensions, syntax highlighting of code blocks, table of contents generation, and custom CSS styling.

FUNCTIONAL REQUIREMENTS:
- Accept a Markdown file path as a command-line argument
- Support standard Markdown: headings (h1-h6), bold, italic, strikethrough, links, images, blockquotes, ordered and unordered lists, horizontal rules, inline code, and code blocks
- Support GitHub Flavored Markdown extensions: tables, task lists (checkboxes), fenced code blocks with language identifiers, autolinks, and footnotes
- Apply syntax highlighting to fenced code blocks based on the specified language (support at least: python, javascript, java, c++, html, css, json, bash)
- Generate a table of contents from headings via --toc flag, inserted at the top of the document with anchor links
- Support custom CSS styling via --css flag (path to a CSS file to embed or link in the output)
- Support wrapping the output in a complete HTML document (with DOCTYPE, head, body) via --full-page flag, or outputting just the HTML fragment (default)
- Support automatic heading ID generation for anchor links based on heading text
- Support converting multiple Markdown files via --batch flag, with optional --index flag to generate an index page linking all converted files
- Print the HTML output to console by default
- Save the HTML to a file via --output flag (default: same base name with .html extension)
- If no input file is given, generate a sample Markdown document demonstrating all supported features (headings, lists, code blocks, tables, images, links, task lists, footnotes), convert it, and save both the Markdown source and HTML output
- Handle errors: invalid Markdown syntax (graceful degradation), missing linked files, and encoding issues

Create a complete Python project for a clean Ubuntu 22.04 machine with only Python 3.10+ installed. Include:
- Source code
- requirements.txt with all dependencies (direct and transitive) pinned to exact versions
- README.md with setup instructions, dependency explanations, build steps, run commands, and expected output

[]

import markdown
import sys
import argparse
import os
from pygments.formatters import HtmlFormatter

def convert_md(md_path, output_path=None, full_page=True, toc=False):
    if not os.path.exists(md_path):
        print(f"Error: {md_path} not found.")
        return

    with open(md_path, 'r', encoding='utf-8') as f:
        text = f.read()
    
    # Extensions for GFM, Table of Contents, and Code Highlighting
    extensions = [
        'extra',          # Tables, footnotes, attr_list, etc.
        'codehilite',     # Syntax highlighting
        'fenced_code',    # GFM style code blocks
        'admonition',     # Warning/Info boxes
        'nl2br'           # Newline to break
    ]
    
    if toc:
        extensions.append('toc')
    
    # Convert Markdown to HTML
    html_body = markdown.markdown(text, extensions=extensions)
    
    # Generate CSS for code highlighting
    formatter = HtmlFormatter(style='friendly', noclasses=False)
    code_css = formatter.get_style_defs('.codehilite')
    
    if full_page:
        # Construct a full HTML document
        title = os.path.basename(md_path)
        html_output = f"""<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <title>{title}</title>
    <style>
        body {{ font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif; line-height: 1.6; max-width: 800px; margin: 0 auto; padding: 2rem; color: #24292e; }}
        table {{ border-collapse: collapse; width: 100%; margin-bottom: 1rem; }}
        table th, table td {{ border: 1px solid #dfe2e5; padding: 6px 13px; }}
        table tr {{ background-color: #fff; border-top: 1px solid #c6cbd1; }}
        table tr:nth-child(2n) {{ background-color: #f6f8fa; }}
        blockquote {{ border-left: 0.25em solid #dfe2e5; color: #6a737d; padding: 0 1em; margin-left: 0; }}
        pre {{ background-color: #f6f8fa; padding: 16px; border-radius: 3px; overflow: auto; }}
        {code_css}
    </style>
</head>
<body>
    {html_body}
</body>
</html>"""
    else:
        html_output = html_body

    if not output_path:
        output_path = os.path.splitext(md_path)[0] + ".html"
        
    with open(output_path, 'w', encoding='utf-8') as f:
        f.write(html_output)
    
    print(f"Successfully converted {md_path} to {output_path}")

def generate_sample(path):
    print(f"Generating sample Markdown: {path}")
    sample_content = """# Sample Document
This is a demonstration of the **Markdown to HTML Converter**.

## Features
- **GFM Support**: Tables, task lists, etc.
- **Syntax Highlighting**:
```python
def hello_world():
    print("Hello, TMLR!")
```

### Table Example
| Item | Price | Status |
|---|---|---|
| Laptop | $1200 | In Stock |
| Mouse | $25 | Out of Stock |

> "Markdown is intended to be as easy-to-read and easy-to-write as is feasible." 
> — John Gruber
"""
    with open(path, "w", encoding='utf-8') as f:
        f.write(sample_content)

def main():
    parser = argparse.ArgumentParser(description="Markdown to HTML Converter")
    parser.add_argument("input", nargs="?", help="Path to Markdown file")
    parser.add_argument("--output", help="Output HTML file path")
    parser.add_argument("--toc", action="store_true", help="Generate Table of Contents")
    parser.add_argument("--fragment", action="store_false", dest="full_page", help="Output HTML fragment only")
    
    args = parser.parse_args()
    
    input_file = args.input
    if not input_file:
        input_file = "sample.md"
        if not os.path.exists(input_file):
            generate_sample(input_file)
            
    convert_md(input_file, args.output, args.full_page, args.toc)

if __name__ == "__main__":
    main()

# Markdown to HTML Converter (Python)

A tool for converting Markdown to high-quality, styled HTML with syntax highlighting and GFM support.

## Setup Instructions

1. Ensure Python 3.10+ is installed.
2. Create a virtual environment:
   ```bash
   python3 -m venv venv
   source venv/bin/activate
   ```
3. Install dependencies:
   ```bash
   pip install -r requirements.txt
   ```

## Run Commands

- **Convert File**:
  ```bash
  python md_converter.py README.md
  ```
- **Generate TOC**:
  ```bash
  python md_converter.py report.md --toc
  ```
- **Run Demo**:
  ```bash
  python md_converter.py
  ```

## Features
- **Syntax Highlighting**: Uses Pygments for beautiful code blocks.
- **GFM Extensions**: Supports tables, fenced code, and more.
- **Styled Output**: Produces clean, readable HTML similar to GitHub's styling.

markdown==3.5.2
Pygments==2.17.2