Document Converter Suite

display_name: 'Document Converter Suite'
short_description: 'Convert documents and run focused PDF or table utilities.'
default_prompt: 'Help me convert or extract content from a document.'

#!/usr/bin/env python3
"""Document Converter Suite (batch)

Batch-convert files in a directory (optionally recursive).

Notes:
  - Uses the same best-effort, structure-first conversions as scripts/convert.py
  - Skips files already in the target extension

Examples:
  python scripts/batch_convert.py ./inbox --to pdf --recursive
  python scripts/batch_convert.py ./inbox --to docx --outdir ./out --overwrite
  python scripts/batch_convert.py ./inbox --to xlsx --pattern "*.pptx"
"""

from __future__ import annotations

import argparse
from pathlib import Path
from typing import Iterable, Optional

from lib.conversion import convert_document
from lib.types import SUPPORTED_INPUT_EXTS, SUPPORTED_OUTPUT_EXTS


def _positive_int(value: str) -> int:
    try:
        i = int(value)
    except ValueError as e:
        raise argparse.ArgumentTypeError(str(e))
    if i <= 0:
        raise argparse.ArgumentTypeError("Must be a positive integer")
    return i


def build_parser() -> argparse.ArgumentParser:
    p = argparse.ArgumentParser(description="Batch convert documents in a folder")
    p.add_argument("indir", type=str, help="Input directory")
    p.add_argument(
        "--to",
        required=True,
        choices=sorted({e.lstrip(".") for e in SUPPORTED_OUTPUT_EXTS}),
        help="Output format: pdf/docx/pptx/xlsx",
    )
    p.add_argument(
        "--outdir",
        default=None,
        help="Optional output directory. Defaults to writing next to each input file.",
    )
    p.add_argument("--recursive", action="store_true", help="Search subdirectories")
    p.add_argument(
        "--pattern",
        default="*",
        help="Glob pattern to filter input files (default: '*'). Example: '*.pdf'",
    )
    p.add_argument(
        "--flatten",
        action="store_true",
        help="If --outdir is set, write all outputs directly into that directory (no subfolders).",
    )
    p.add_argument("--max-pages", type=_positive_int, default=200)
    p.add_argument("--max-chars", type=_positive_int, default=300000)
    p.add_argument("--max-rows", type=_positive_int, default=200)
    p.add_argument("--max-cols", type=_positive_int, default=50)
    p.add_argument("--overwrite", action="store_true")
    p.add_argument("--verbose", action="store_true")
    return p


def iter_files(indir: Path, recursive: bool, pattern: str) -> Iterable[Path]:
    if recursive:
        for p in indir.rglob(pattern):
            if p.is_file():
                yield p
    else:
        for p in indir.glob(pattern):
            if p.is_file():
                yield p


def main(argv: Optional[Iterable[str]] = None) -> int:
    args = build_parser().parse_args(argv)

    indir = Path(args.indir).expanduser().resolve()
    if not indir.exists() or not indir.is_dir():
        raise SystemExit(f"Input directory not found: {indir}")

    out_ext = f".{args.to.lower().lstrip('.')}"
    if out_ext not in SUPPORTED_OUTPUT_EXTS:
        raise SystemExit(f"Unsupported output extension: {out_ext}")

    outdir = Path(args.outdir).expanduser().resolve() if args.outdir else None
    if outdir:
        outdir.mkdir(parents=True, exist_ok=True)

    converted = 0
    skipped = 0
    failed = 0

    for in_path in iter_files(indir, args.recursive, args.pattern):
        if in_path.suffix.lower() not in SUPPORTED_INPUT_EXTS:
            continue
        if in_path.suffix.lower() == out_ext:
            skipped += 1
            continue

        if outdir:
            if args.flatten:
                out_path = outdir / (in_path.stem + out_ext)
            else:
                rel = in_path.relative_to(indir)
                out_path = (outdir / rel).with_suffix(out_ext)
                out_path.parent.mkdir(parents=True, exist_ok=True)
        else:
            out_path = in_path.with_suffix(out_ext)

        if out_path.exists() and not args.overwrite:
            skipped += 1
            if args.verbose:
                print(f"↷ skip (exists): {out_path}")
            continue

        try:
            convert_document(
                input_path=in_path,
                output_path=out_path,
                max_pages=args.max_pages,
                max_chars=args.max_chars,
                max_rows=args.max_rows,
                max_cols=args.max_cols,
                verbose=args.verbose,
            )
            converted += 1
            if args.verbose:
                print(f"✓ {in_path.name} -> {out_path.name}")
        except Exception as e:
            failed += 1
            if args.verbose:
                print(f"✗ failed: {in_path} ({e})")

    print(f"Done. converted={converted} skipped={skipped} failed={failed}")
    return 0 if failed == 0 else 2


if __name__ == "__main__":
    raise SystemExit(main())

#!/usr/bin/env python3
"""Document Converter Suite (single-file)

Convert between PDF, DOCX, PPTX, and XLSX with lightweight, dependency-minimal rules.

This intentionally does *not* attempt pixel-perfect layout conversion. It focuses on:
  - Extracting text and basic structure (headings, bullets, tables)
  - Rebuilding that content in the target format

Supported formats: .pdf, .docx, .pptx, .xlsx

Examples:
  python scripts/convert.py input.pdf --to docx
  python scripts/convert.py deck.pptx --to pdf --out deck.pdf
  python scripts/convert.py sheet.xlsx --to pptx --max-rows 40 --max-cols 10
"""

from __future__ import annotations

import argparse
import os
from pathlib import Path
from typing import Iterable, Optional

from lib.conversion import convert_document
from lib.types import SUPPORTED_INPUT_EXTS, SUPPORTED_OUTPUT_EXTS


def _positive_int(value: str) -> int:
    try:
        i = int(value)
    except ValueError as e:
        raise argparse.ArgumentTypeError(str(e))
    if i <= 0:
        raise argparse.ArgumentTypeError("Must be a positive integer")
    return i


def build_parser() -> argparse.ArgumentParser:
    p = argparse.ArgumentParser(description="Convert a document between PDF/DOCX/PPTX/XLSX")
    p.add_argument("input", type=str, help="Path to input file")
    p.add_argument(
        "--to",
        required=True,
        choices=sorted(SUPPORTED_OUTPUT_EXTS),
        help="Output format (extension without dot), e.g. pdf, docx, pptx, xlsx",
    )
    p.add_argument(
        "--out",
        default=None,
        help="Optional output path. If omitted, write next to input with new extension.",
    )
    p.add_argument(
        "--max-pages",
        type=_positive_int,
        default=200,
        help="Safety cap for PDF page processing (default: 200)",
    )
    p.add_argument(
        "--max-chars",
        type=_positive_int,
        default=300000,
        help="Safety cap for extracted text size per document (default: 300000)",
    )
    p.add_argument(
        "--max-rows",
        type=_positive_int,
        default=200,
        help="Safety cap for spreadsheet rows per sheet (default: 200)",
    )
    p.add_argument(
        "--max-cols",
        type=_positive_int,
        default=50,
        help="Safety cap for spreadsheet columns per sheet (default: 50)",
    )
    p.add_argument(
        "--overwrite",
        action="store_true",
        help="Overwrite output file if it exists",
    )
    p.add_argument(
        "--verbose",
        action="store_true",
        help="Print extra progress output",
    )
    return p


def main(argv: Optional[Iterable[str]] = None) -> int:
    args = build_parser().parse_args(argv)

    in_path = Path(args.input).expanduser().resolve()
    if not in_path.exists():
        raise SystemExit(f"Input not found: {in_path}")
    if in_path.suffix.lower() not in SUPPORTED_INPUT_EXTS:
        raise SystemExit(
            f"Unsupported input extension '{in_path.suffix}'. Supported: {sorted(SUPPORTED_INPUT_EXTS)}"
        )

    out_ext = f".{args.to.lower().lstrip('.')}"
    if out_ext not in SUPPORTED_OUTPUT_EXTS:
        raise SystemExit(f"Unsupported output extension '{out_ext}'.")

    if args.out:
        out_path = Path(args.out).expanduser().resolve()
    else:
        out_path = in_path.with_suffix(out_ext)

    if out_path.exists() and not args.overwrite:
        raise SystemExit(
            f"Output exists: {out_path}\nUse --overwrite or provide a different --out path."
        )

    out_path.parent.mkdir(parents=True, exist_ok=True)

    convert_document(
        input_path=in_path,
        output_path=out_path,
        max_pages=args.max_pages,
        max_chars=args.max_chars,
        max_rows=args.max_rows,
        max_cols=args.max_cols,
        verbose=args.verbose,
    )

    if args.verbose:
        print(f"✅ Wrote: {out_path}")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

#!/usr/bin/env python3
"""
Form Filler - Fill PDF forms programmatically.
"""

import argparse
import json
import os
from pathlib import Path
from typing import Dict, List, Any, Optional

import pandas as pd

try:
    import fitz  # PyMuPDF
    PYMUPDF_AVAILABLE = True
except ImportError:
    PYMUPDF_AVAILABLE = False


class FormFiller:
    """Fill PDF forms with data."""

    def __init__(self):
        """Initialize the form filler."""
        if not PYMUPDF_AVAILABLE:
            raise ImportError("PyMuPDF (fitz) is required for form filling")

        self.doc = None
        self.filepath = None
        self.mapping = {}

    def load(self, filepath: str) -> 'FormFiller':
        """Load a PDF form."""
        self.filepath = filepath
        self.doc = fitz.open(filepath)
        return self

    def list_fields(self) -> List[Dict]:
        """List all form fields."""
        if not self.doc:
            raise ValueError("No document loaded")

        fields = []

        for page_num, page in enumerate(self.doc):
            widgets = page.widgets()
            if widgets:
                for widget in widgets:
                    field_info = {
                        "name": widget.field_name,
                        "type": self._get_field_type(widget.field_type),
                        "page": page_num,
                        "value": widget.field_value,
                        "rect": list(widget.rect)
                    }

                    # Get options for choice fields
                    if widget.field_type in [fitz.PDF_WIDGET_TYPE_LISTBOX,
                                             fitz.PDF_WIDGET_TYPE_COMBOBOX]:
                        field_info["options"] = widget.choice_values

                    fields.append(field_info)

        return fields

    def _get_field_type(self, field_type: int) -> str:
        """Convert field type constant to string."""
        type_map = {
            fitz.PDF_WIDGET_TYPE_TEXT: "text",
            fitz.PDF_WIDGET_TYPE_CHECKBOX: "checkbox",
            fitz.PDF_WIDGET_TYPE_RADIOBUTTON: "radio",
            fitz.PDF_WIDGET_TYPE_LISTBOX: "listbox",
            fitz.PDF_WIDGET_TYPE_COMBOBOX: "dropdown",
            fitz.PDF_WIDGET_TYPE_BUTTON: "button",
            fitz.PDF_WIDGET_TYPE_SIGNATURE: "signature"
        }
        return type_map.get(field_type, "unknown")

    def get_field_info(self, field_name: str) -> Optional[Dict]:
        """Get information about a specific field."""
        fields = self.list_fields()
        for field in fields:
            if field["name"] == field_name:
                return field
        return None

    def get_field_value(self, field_name: str) -> Any:
        """Get current value of a field."""
        field_info = self.get_field_info(field_name)
        if field_info:
            return field_info.get("value")
        return None

    def set_mapping(self, mapping: Dict[str, str]) -> 'FormFiller':
        """Set data key to field name mapping."""
        self.mapping = mapping
        return self

    def fill(self, data: Dict) -> 'FormFiller':
        """Fill form with data dictionary."""
        if not self.doc:
            raise ValueError("No document loaded")

        for key, value in data.items():
            # Apply mapping if exists
            field_name = self.mapping.get(key, key)
            self.fill_field(field_name, value)

        return self

    def fill_field(self, name: str, value: Any) -> 'FormFiller':
        """Fill a specific form field."""
        if not self.doc:
            raise ValueError("No document loaded")

        for page in self.doc:
            widgets = page.widgets()
            if widgets:
                for widget in widgets:
                    if widget.field_name == name:
                        self._set_widget_value(widget, value)

        return self

    def _set_widget_value(self, widget, value: Any):
        """Set value on a widget based on its type."""
        field_type = widget.field_type

        if field_type == fitz.PDF_WIDGET_TYPE_TEXT:
            widget.field_value = str(value) if value is not None else ""
            widget.update()

        elif field_type == fitz.PDF_WIDGET_TYPE_CHECKBOX:
            # Checkboxes: True/False or "Yes"/"Off"
            if isinstance(value, bool):
                widget.field_value = "Yes" if value else "Off"
            else:
                widget.field_value = str(value)
            widget.update()

        elif field_type == fitz.PDF_WIDGET_TYPE_RADIOBUTTON:
            widget.field_value = str(value)
            widget.update()

        elif field_type in [fitz.PDF_WIDGET_TYPE_LISTBOX, fitz.PDF_WIDGET_TYPE_COMBOBOX]:
            widget.field_value = str(value)
            widget.update()

    def fill_from_json(self, filepath: str) -> 'FormFiller':
        """Fill form from JSON file."""
        with open(filepath) as f:
            data = json.load(f)

        return self.fill(data)

    def fill_from_csv_row(self, row: Dict) -> 'FormFiller':
        """Fill form from a CSV row dictionary."""
        return self.fill(row)

    def flatten(self) -> 'FormFiller':
        """Flatten form (make fields non-editable)."""
        if not self.doc:
            raise ValueError("No document loaded")

        for page in self.doc:
            # Get all annotations (widgets are annotations)
            annots = page.annots()
            if annots:
                for annot in annots:
                    # Set the annotation to be read-only
                    annot.set_flags(fitz.ANNOT_BF_ReadOnly)

        return self

    def save(self, filepath: str, flatten: bool = False) -> str:
        """Save filled form to file."""
        if not self.doc:
            raise ValueError("No document loaded")

        if flatten:
            self.flatten()

        self.doc.save(filepath, garbage=4, deflate=True)
        return filepath

    def close(self):
        """Close the document."""
        if self.doc:
            self.doc.close()

    def batch_fill(self, input_form: str, data_file: str,
                  output_dir: str, name_field: str = None) -> List[str]:
        """
        Fill multiple copies of form from data file.

        Args:
            input_form: Path to PDF form template
            data_file: Path to JSON or CSV data file
            output_dir: Output directory for filled forms
            name_field: Field to use for naming output files

        Returns:
            List of generated file paths
        """
        output_path = Path(output_dir)
        output_path.mkdir(parents=True, exist_ok=True)

        # Load data
        if data_file.endswith('.json'):
            with open(data_file) as f:
                data = json.load(f)
                if not isinstance(data, list):
                    data = [data]
        else:
            df = pd.read_csv(data_file)
            data = df.to_dict(orient='records')

        generated = []
        base_name = Path(input_form).stem

        for i, row in enumerate(data):
            # Load fresh copy of form
            self.load(input_form)

            # Fill with data
            self.fill(row)

            # Determine output filename
            if name_field and name_field in row:
                filename = f"{base_name}_{row[name_field]}.pdf"
            else:
                filename = f"{base_name}_{i}.pdf"

            # Clean filename
            filename = "".join(c if c.isalnum() or c in '._-' else '_' for c in filename)

            output_file = output_path / filename
            self.save(str(output_file))
            generated.append(str(output_file))

            self.close()
            print(f"Generated: {filename}")

        return generated


def main():
    parser = argparse.ArgumentParser(description="Form Filler")

    parser.add_argument("--input", "-i", required=True, help="Input PDF form")
    parser.add_argument("--output", "-o", help="Output PDF file")
    parser.add_argument("--data", "-d", help="Data file (JSON)")

    parser.add_argument("--list-fields", action="store_true", help="List form fields")

    parser.add_argument("--batch", help="Batch fill from CSV/JSON data file")
    parser.add_argument("--output-dir", help="Output directory for batch")
    parser.add_argument("--name-field", help="Field to use for output filenames")

    parser.add_argument("--mapping", help="Field mapping JSON file")
    parser.add_argument("--flatten", action="store_true", help="Flatten output PDF")

    args = parser.parse_args()

    filler = FormFiller()

    # List fields mode
    if args.list_fields:
        filler.load(args.input)
        fields = filler.list_fields()

        print(f"Form: {args.input}")
        print(f"Total fields: {len(fields)}\n")

        for field in fields:
            print(f"Name: {field['name']}")
            print(f"  Type: {field['type']}")
            print(f"  Page: {field['page'] + 1}")
            if field.get('value'):
                print(f"  Current value: {field['value']}")
            if field.get('options'):
                print(f"  Options: {field['options']}")
            print()

        filler.close()
        return

    # Batch mode
    if args.batch:
        output_dir = args.output_dir or "filled_forms"
        generated = filler.batch_fill(
            args.input,
            args.batch,
            output_dir,
            name_field=args.name_field
        )
        print(f"\nGenerated {len(generated)} filled forms in: {output_dir}")
        return

    # Single form filling
    if args.data and args.output:
        filler.load(args.input)

        # Load mapping if provided
        if args.mapping:
            with open(args.mapping) as f:
                filler.set_mapping(json.load(f))

        # Fill from data
        filler.fill_from_json(args.data)

        # Save
        filler.save(args.output, flatten=args.flatten)
        print(f"Filled form saved: {args.output}")

        # Show summary
        with open(args.data) as f:
            data = json.load(f)
        print(f"Filled {len(data)} fields")

        filler.close()
        return

    parser.print_help()


if __name__ == "__main__":
    main()

"""Internal helper modules for Document Converter Suite."""

from __future__ import annotations

import shutil
import sys
from pathlib import Path
from typing import List, Optional

from docx import Document as DocxDocument

from .csv_reader import read_csv_content
from .csv_writer import write_csv_from_rows
from .docx_reader import read_docx_content
from .docx_writer import write_docx_from_text
from .html_reader import read_html_content
from .html_writer import write_html_from_sections
from .md_reader import read_md_content
from .md_writer import write_md_from_sections
from .pdf_reader import read_pdf_text
from .pdf_writer import write_pdf_from_sections
from .pptx_reader import read_pptx_content
from .pptx_writer import write_pptx_from_slides
from .txt_reader import read_txt_content
from .txt_writer import write_txt_from_lines
from .types import SUPPORTED_INPUT_EXTS, SUPPORTED_OUTPUT_EXTS
from .utils import chunk_list, guess_bullets, safe_cell_value
from .xlsx_reader import read_xlsx_content
from .xlsx_writer import write_xlsx_from_sheets


def _print_warnings(warnings: List[str]) -> None:
    """Print warnings to stderr with visual indicator."""
    for warning in warnings:
        print(f"⚠️  {warning}", file=sys.stderr)


def convert_document(
    input_path: Path,
    output_path: Path,
    max_pages: int = 200,
    max_chars: int = 300000,
    max_rows: int = 200,
    max_cols: int = 50,
    verbose: bool = False,
) -> None:
    """Convert a single document between PDF, DOCX, PPTX, XLSX.

    This is best-effort conversion focused on text and basic tables.
    """
    in_ext = input_path.suffix.lower()
    out_ext = output_path.suffix.lower()

    if in_ext not in SUPPORTED_INPUT_EXTS:
        raise ValueError(f"Unsupported input extension: {in_ext}")
    if out_ext not in SUPPORTED_OUTPUT_EXTS:
        raise ValueError(f"Unsupported output extension: {out_ext}")

    # Shortcut: same extension -> copy
    if in_ext == out_ext:
        if verbose:
            print(f"Copying (same format): {input_path} -> {output_path}")
        shutil.copy2(str(input_path), str(output_path))
        return

    # === Convert to DOCX ===
    if out_ext == ".docx":
        if in_ext == ".pdf":
            _pdf_to_docx(input_path, output_path, max_pages=max_pages, max_chars=max_chars)
            return
        if in_ext == ".pptx":
            _pptx_to_docx(input_path, output_path, max_chars=max_chars)
            return
        if in_ext == ".xlsx":
            _xlsx_to_docx(input_path, output_path, max_rows=max_rows, max_cols=max_cols)
            return
        if in_ext == ".md":
            _md_to_docx(input_path, output_path, max_chars=max_chars)
            return
        if in_ext == ".txt":
            _txt_to_docx(input_path, output_path, max_chars=max_chars)
            return
        if in_ext == ".csv":
            _csv_to_docx(input_path, output_path, max_rows=max_rows, max_cols=max_cols)
            return
        if in_ext == ".html":
            _html_to_docx(input_path, output_path, max_chars=max_chars)
            return

    # === Convert to PPTX ===
    if out_ext == ".pptx":
        if in_ext == ".pdf":
            _pdf_to_pptx(input_path, output_path, max_pages=max_pages, max_chars=max_chars)
            return
        if in_ext == ".docx":
            _docx_to_pptx(input_path, output_path, max_chars=max_chars)
            return
        if in_ext == ".xlsx":
            _xlsx_to_pptx(input_path, output_path, max_rows=max_rows, max_cols=max_cols)
            return
        if in_ext == ".md":
            _md_to_pptx(input_path, output_path, max_chars=max_chars)
            return
        if in_ext == ".txt":
            _txt_to_pptx(input_path, output_path, max_chars=max_chars)
            return
        if in_ext == ".csv":
            _csv_to_pptx(input_path, output_path, max_rows=max_rows, max_cols=max_cols)
            return
        if in_ext == ".html":
            _html_to_pptx(input_path, output_path, max_chars=max_chars)
            return

    # === Convert to XLSX ===
    if out_ext == ".xlsx":
        if in_ext == ".pdf":
            _pdf_to_xlsx(input_path, output_path, max_pages=max_pages, max_chars=max_chars)
            return
        if in_ext == ".docx":
            _docx_to_xlsx(input_path, output_path, max_chars=max_chars)
            return
        if in_ext == ".pptx":
            _pptx_to_xlsx(input_path, output_path, max_chars=max_chars)
            return
        if in_ext == ".md":
            _md_to_xlsx(input_path, output_path, max_chars=max_chars)
            return
        if in_ext == ".txt":
            _txt_to_xlsx(input_path, output_path, max_chars=max_chars)
            return
        if in_ext == ".csv":
            _csv_to_xlsx(input_path, output_path, max_rows=max_rows, max_cols=max_cols)
            return
        if in_ext == ".html":
            _html_to_xlsx(input_path, output_path, max_chars=max_chars)
            return

    # === Convert to PDF ===
    if out_ext == ".pdf":
        if in_ext == ".docx":
            _docx_to_pdf(input_path, output_path, max_chars=max_chars)
            return
        if in_ext == ".pptx":
            _pptx_to_pdf(input_path, output_path, max_chars=max_chars)
            return
        if in_ext == ".xlsx":
            _xlsx_to_pdf(input_path, output_path, max_rows=max_rows, max_cols=max_cols)
            return
        if in_ext == ".md":
            _md_to_pdf(input_path, output_path, max_chars=max_chars)
            return
        if in_ext == ".txt":
            _txt_to_pdf(input_path, output_path, max_chars=max_chars)
            return
        if in_ext == ".html":
            _html_to_pdf(input_path, output_path, max_chars=max_chars)
            return

    # === Convert to TXT ===
    if out_ext == ".txt":
        if in_ext == ".pdf":
            _pdf_to_txt(input_path, output_path, max_pages=max_pages, max_chars=max_chars)
            return
        if in_ext == ".docx":
            _docx_to_txt(input_path, output_path, max_chars=max_chars)
            return
        if in_ext == ".pptx":
            _pptx_to_txt(input_path, output_path, max_chars=max_chars)
            return
        if in_ext == ".xlsx":
            _xlsx_to_txt(input_path, output_path, max_rows=max_rows, max_cols=max_cols)
            return
        if in_ext == ".md":
            _md_to_txt(input_path, output_path, max_chars=max_chars)
            return
        if in_ext == ".csv":
            _csv_to_txt(input_path, output_path, max_rows=max_rows, max_cols=max_cols)
            return
        if in_ext == ".html":
            _html_to_txt(input_path, output_path, max_chars=max_chars)
            return

    # === Convert to CSV ===
    if out_ext == ".csv":
        if in_ext == ".xlsx":
            _xlsx_to_csv(input_path, output_path, max_rows=max_rows, max_cols=max_cols)
            return
        if in_ext == ".docx":
            _docx_to_csv(input_path, output_path, max_chars=max_chars)
            return
        if in_ext == ".pptx":
            _pptx_to_csv(input_path, output_path, max_chars=max_chars)
            return
        if in_ext == ".txt":
            _txt_to_csv(input_path, output_path, max_chars=max_chars)
            return
        if in_ext == ".html":
            _html_to_csv(input_path, output_path, max_chars=max_chars)
            return

    # === Convert to MD ===
    if out_ext == ".md":
        if in_ext == ".docx":
            _docx_to_md(input_path, output_path, max_chars=max_chars)
            return
        if in_ext == ".txt":
            _txt_to_md(input_path, output_path, max_chars=max_chars)
            return
        if in_ext == ".pdf":
            _pdf_to_md(input_path, output_path, max_pages=max_pages, max_chars=max_chars)
            return
        if in_ext == ".pptx":
            _pptx_to_md(input_path, output_path, max_chars=max_chars)
            return
        if in_ext == ".xlsx":
            _xlsx_to_md(input_path, output_path, max_rows=max_rows, max_cols=max_cols)
            return
        if in_ext == ".html":
            _html_to_md(input_path, output_path, max_chars=max_chars)
            return

    # === Convert to HTML ===
    if out_ext == ".html":
        if in_ext == ".md":
            _md_to_html(input_path, output_path, max_chars=max_chars)
            return
        if in_ext == ".docx":
            _docx_to_html(input_path, output_path, max_chars=max_chars)
            return
        if in_ext == ".txt":
            _txt_to_html(input_path, output_path, max_chars=max_chars)
            return
        if in_ext == ".pdf":
            _pdf_to_html(input_path, output_path, max_pages=max_pages, max_chars=max_chars)
            return
        if in_ext == ".pptx":
            _pptx_to_html(input_path, output_path, max_chars=max_chars)
            return
        if in_ext == ".xlsx":
            _xlsx_to_html(input_path, output_path, max_rows=max_rows, max_cols=max_cols)
            return
        if in_ext == ".csv":
            _csv_to_html(input_path, output_path, max_rows=max_rows, max_cols=max_cols)
            return

    raise ValueError(f"No conversion path implemented: {in_ext} -> {out_ext}")


# --------------------------
# PDF -> *
# --------------------------

def _pdf_to_docx(input_path: Path, output_path: Path, max_pages: int, max_chars: int) -> None:
    pdf = read_pdf_text(input_path, max_pages=max_pages, max_chars=max_chars)
    doc = DocxDocument()
    doc.add_heading(input_path.stem, level=1)
    for i, page_text in enumerate(pdf.pages, start=1):
        doc.add_heading(f"Page {i}", level=2)
        for ln in page_text.splitlines():
            ln = (ln or "").strip()
            if not ln:
                continue
            doc.add_paragraph(ln)
        if i < len(pdf.pages):
            doc.add_page_break()
    doc.save(str(output_path))


def _pdf_to_pptx(input_path: Path, output_path: Path, max_pages: int, max_chars: int) -> None:
    pdf = read_pdf_text(input_path, max_pages=max_pages, max_chars=max_chars)
    slides: List[dict] = []
    for i, page_text in enumerate(pdf.pages, start=1):
        slides.append({"title": f"Page {i}", "bullets": guess_bullets(page_text)})
    write_pptx_from_slides(output_path, slides, title=input_path.stem)


def _pdf_to_xlsx(input_path: Path, output_path: Path, max_pages: int, max_chars: int) -> None:
    pdf = read_pdf_text(input_path, max_pages=max_pages, max_chars=max_chars)
    rows: List[List[str]] = []
    for i, page_text in enumerate(pdf.pages, start=1):
        rows.append([f"=== Page {i} ==="])
        for ln in page_text.splitlines():
            ln = (ln or "").strip()
            if ln:
                rows.append([ln])
        rows.append([""])
    write_xlsx_from_sheets(output_path, [{"name": "PDF Text", "rows": rows}])


# --------------------------
# DOCX -> *
# --------------------------

def _docx_to_pptx(input_path: Path, output_path: Path, max_chars: int) -> None:
    content = read_docx_content(input_path, max_chars=max_chars)

    # Heuristic: if there are headings, start slides at headings.
    slides: List[dict] = []
    current_title: Optional[str] = None
    current_bullets: List[str] = []

    def flush():
        nonlocal current_title, current_bullets
        if current_title or current_bullets:
            slides.append({"title": current_title or "", "bullets": current_bullets})
        current_title = None
        current_bullets = []

    for p in content.paragraphs:
        # Treat lines that match known headings as slide boundaries
        if p in set(content.headings):
            flush()
            current_title = p
            continue
        # Chunk big docs into manageable slides
        current_bullets.append(p)
        if len(current_bullets) >= 10:
            flush()

    flush()
    if not slides:
        slides = [{"title": input_path.stem, "bullets": content.paragraphs[:10]}]

    # Normalize bullets a bit
    for s in slides:
        s["bullets"] = [b for b in guess_bullets("\n".join(s.get("bullets") or []), max_lines=12)]

    write_pptx_from_slides(output_path, slides, title=input_path.stem)


def _docx_to_xlsx(input_path: Path, output_path: Path, max_chars: int) -> None:
    content = read_docx_content(input_path, max_chars=max_chars)

    sheets: List[dict] = []

    # Text sheet
    text_rows = [[p] for p in content.paragraphs]
    sheets.append({"name": "Text", "rows": text_rows})

    # Tables -> their own sheets
    for idx, t in enumerate(content.tables, start=1):
        sheets.append({"name": f"Table{idx}", "rows": t.rows})

    write_xlsx_from_sheets(output_path, sheets)


def _docx_to_pdf(input_path: Path, output_path: Path, max_chars: int) -> None:
    content = read_docx_content(input_path, max_chars=max_chars)
    tables = [t.rows for t in content.tables]
    sections = [{"heading": input_path.stem, "paragraphs": content.paragraphs, "tables": tables}]
    write_pdf_from_sections(output_path, title=input_path.stem, sections=sections)


# --------------------------
# PPTX -> *
# --------------------------

def _pptx_to_docx(input_path: Path, output_path: Path, max_chars: int) -> None:
    content = read_pptx_content(input_path, max_chars=max_chars)

    doc = DocxDocument()
    doc.add_heading(input_path.stem, level=1)

    for s in content.slides:
        heading = s.title or f"Slide {s.index}"
        doc.add_heading(heading, level=2)

        # Text blocks -> bullets-ish
        for block in s.texts:
            for bullet in guess_bullets(block, max_lines=20):
                doc.add_paragraph(bullet, style="List Bullet")

        # Tables
        for t_i, t in enumerate(s.tables, start=1):
            if not t:
                continue
            doc.add_paragraph("")
            doc.add_heading(f"Table {t_i}", level=3)
            n_rows = len(t)
            n_cols = max((len(r) for r in t), default=0)
            if n_cols <= 0:
                continue
            table = doc.add_table(rows=n_rows, cols=n_cols)
            for r_i, row in enumerate(t):
                for c_i in range(n_cols):
                    table.cell(r_i, c_i).text = safe_cell_value(row[c_i] if c_i < len(row) else "")

    doc.save(str(output_path))


def _pptx_to_xlsx(input_path: Path, output_path: Path, max_chars: int) -> None:
    content = read_pptx_content(input_path, max_chars=max_chars)

    # Slides sheet: one row per slide with combined text
    rows: List[List[str]] = [["Slide", "Title", "Text"]]
    for s in content.slides:
        combined = "\n\n".join(s.texts)
        rows.append([str(s.index), s.title, combined])

    sheets: List[dict] = [{"name": "Slides", "rows": rows}]

    # Any tables: each table becomes its own sheet (bounded name)
    t_counter = 1
    for s in content.slides:
        for t in s.tables:
            name = f"Table{t_counter}"[:31]
            sheets.append({"name": name, "rows": t})
            t_counter += 1

    write_xlsx_from_sheets(output_path, sheets)


def _pptx_to_pdf(input_path: Path, output_path: Path, max_chars: int) -> None:
    content = read_pptx_content(input_path, max_chars=max_chars)
    sections: List[dict] = []
    for s in content.slides:
        heading = s.title or f"Slide {s.index}"
        paras: List[str] = []
        for block in s.texts:
            paras.extend(guess_bullets(block, max_lines=25))
        tables = s.tables
        sections.append({"heading": heading, "paragraphs": paras, "tables": tables})
    write_pdf_from_sections(output_path, title=input_path.stem, sections=sections)


# --------------------------
# XLSX -> *
# --------------------------

def _xlsx_to_docx(input_path: Path, output_path: Path, max_rows: int, max_cols: int) -> None:
    content = read_xlsx_content(input_path, max_rows=max_rows, max_cols=max_cols)
    _print_warnings(content.warnings)

    doc = DocxDocument()
    doc.add_heading(input_path.stem, level=1)

    for sh in content.sheets:
        doc.add_heading(sh.name, level=2)
        if not sh.cells:
            doc.add_paragraph("(empty sheet)")
            continue
        rows = sh.cells
        n_rows = len(rows)
        n_cols = max((len(r) for r in rows), default=0)
        table = doc.add_table(rows=n_rows, cols=n_cols)
        for r_i, row in enumerate(rows):
            for c_i in range(n_cols):
                table.cell(r_i, c_i).text = safe_cell_value(row[c_i] if c_i < len(row) else "")
        doc.add_paragraph("")

    doc.save(str(output_path))


def _xlsx_to_pptx(input_path: Path, output_path: Path, max_rows: int, max_cols: int) -> None:
    content = read_xlsx_content(input_path, max_rows=max_rows, max_cols=max_cols)
    _print_warnings(content.warnings)

    slides: List[dict] = []
    for sh in content.sheets:
        rows = sh.cells
        # If small enough, push it as a table; otherwise summarize first column as bullets.
        if len(rows) <= 20 and (max((len(r) for r in rows), default=0) <= 10):
            slides.append({"title": sh.name, "bullets": [], "tables": [rows]})
        else:
            first_col = [r[0] for r in rows if r and r[0]]
            bullets = first_col[:12] if first_col else ["(sheet too large to render as table)"]
            slides.append({"title": sh.name, "bullets": bullets})

    write_pptx_from_slides(output_path, slides, title=input_path.stem)


def _xlsx_to_pdf(input_path: Path, output_path: Path, max_rows: int, max_cols: int) -> None:
    content = read_xlsx_content(input_path, max_rows=max_rows, max_cols=max_cols)
    _print_warnings(content.warnings)
    sections: List[dict] = []
    for sh in content.sheets:
        sections.append({"heading": sh.name, "paragraphs": [], "tables": [sh.cells]})
    write_pdf_from_sections(output_path, title=input_path.stem, sections=sections)


# --------------------------
# TXT -> *
# --------------------------

def _txt_to_docx(input_path: Path, output_path: Path, max_chars: int) -> None:
    """Convert plain text to DOCX: lines become paragraphs."""
    content = read_txt_content(input_path, max_chars=max_chars)
    doc = DocxDocument()
    doc.add_heading(input_path.stem, level=1)
    for line in content.lines:
        if line.strip():
            doc.add_paragraph(line)
    doc.save(str(output_path))


def _txt_to_pptx(input_path: Path, output_path: Path, max_chars: int) -> None:
    """Convert plain text to PPTX: chunk lines into slides."""
    content = read_txt_content(input_path, max_chars=max_chars)
    slides: List[dict] = []

    # Chunk lines into slides (10-12 lines per slide)
    lines = [l for l in content.lines if l.strip()]
    for chunk in chunk_list(lines, size=12):
        slides.append({"title": "", "bullets": chunk})

    if not slides:
        slides = [{"title": input_path.stem, "bullets": ["(empty file)"]}]

    write_pptx_from_slides(output_path, slides, title=input_path.stem)


def _txt_to_xlsx(input_path: Path, output_path: Path, max_chars: int) -> None:
    """Convert plain text to XLSX: one line per row."""
    content = read_txt_content(input_path, max_chars=max_chars)
    rows: List[List[str]] = [[line] for line in content.lines]
    write_xlsx_from_sheets(output_path, [{"name": "Text", "rows": rows}])


def _txt_to_pdf(input_path: Path, output_path: Path, max_chars: int) -> None:
    """Convert plain text to PDF: lines become paragraphs."""
    content = read_txt_content(input_path, max_chars=max_chars)
    paragraphs = [line for line in content.lines if line.strip()]
    sections: List[dict] = [{"heading": input_path.stem, "paragraphs": paragraphs, "tables": []}]
    write_pdf_from_sections(output_path, title=input_path.stem, sections=sections)


def _txt_to_csv(input_path: Path, output_path: Path, max_chars: int) -> None:
    """Convert plain text to CSV: one line per row, single column."""
    content = read_txt_content(input_path, max_chars=max_chars)
    rows: List[List[str]] = [[line] for line in content.lines]
    write_csv_from_rows(output_path, rows=rows)


# --------------------------
# * -> TXT
# --------------------------

def _pdf_to_txt(input_path: Path, output_path: Path, max_pages: int, max_chars: int) -> None:
    """Convert PDF to plain text with page separators."""
    pdf = read_pdf_text(input_path, max_pages=max_pages, max_chars=max_chars)
    lines: List[str] = []
    for i, page_text in enumerate(pdf.pages, start=1):
        lines.append(f"=== Page {i} ===")
        lines.extend(page_text.splitlines())
        lines.append("")
    write_txt_from_lines(output_path, lines)


def _docx_to_txt(input_path: Path, output_path: Path, max_chars: int) -> None:
    """Convert DOCX to plain text: flatten paragraphs with heading markers."""
    content = read_docx_content(input_path, max_chars=max_chars)
    lines: List[str] = []
    heading_set = set(content.headings)

    for para in content.paragraphs:
        if para in heading_set:
            lines.append("")
            lines.append(f"## {para}")
            lines.append("")
        else:
            lines.append(para)

    write_txt_from_lines(output_path, lines)


def _pptx_to_txt(input_path: Path, output_path: Path, max_chars: int) -> None:
    """Convert PPTX to plain text: slide title + bullets."""
    content = read_pptx_content(input_path, max_chars=max_chars)
    lines: List[str] = []

    for slide in content.slides:
        if slide.title:
            lines.append(f"## {slide.title}")
            lines.append("")
        for text in slide.texts:
            lines.append(f"  - {text}")
        lines.append("")

    write_txt_from_lines(output_path, lines)


def _xlsx_to_txt(input_path: Path, output_path: Path, max_rows: int, max_cols: int) -> None:
    """Convert XLSX to plain text: sheet headers + cell values."""
    content = read_xlsx_content(input_path, max_rows=max_rows, max_cols=max_cols)
    _print_warnings(content.warnings)
    lines: List[str] = []

    for sh in content.sheets:
        lines.append(f"### {sh.name}")
        lines.append("")
        for row in sh.cells:
            line = " | ".join(safe_cell_value(cell) for cell in row)
            lines.append(line)
        lines.append("")

    write_txt_from_lines(output_path, lines)


def _csv_to_txt(input_path: Path, output_path: Path, max_rows: int, max_cols: int) -> None:
    """Convert CSV to plain text: pipe-separated values."""
    content = read_csv_content(input_path, max_rows=max_rows, max_cols=max_cols)
    lines: List[str] = []

    for row in content.rows:
        lines.append(" | ".join(row))

    write_txt_from_lines(output_path, lines)


# --------------------------
# CSV -> *
# --------------------------

def _csv_to_docx(input_path: Path, output_path: Path, max_rows: int, max_cols: int) -> None:
    """Convert CSV to DOCX: first row as heading, rest as table."""
    content = read_csv_content(input_path, max_rows=max_rows, max_cols=max_cols)
    doc = DocxDocument()
    doc.add_heading(input_path.stem, level=1)

    if not content.rows:
        doc.add_paragraph("(empty file)")
    else:
        # Create table from CSV rows
        n_rows = len(content.rows)
        n_cols = max((len(r) for r in content.rows), default=0)
        table = doc.add_table(rows=n_rows, cols=n_cols)

        for r_i, row in enumerate(content.rows):
            for c_i in range(n_cols):
                cell_value = row[c_i] if c_i < len(row) else ""
                table.cell(r_i, c_i).text = cell_value

    doc.save(str(output_path))


def _csv_to_pptx(input_path: Path, output_path: Path, max_rows: int, max_cols: int) -> None:
    """Convert CSV to PPTX: headers + rows as table slide."""
    content = read_csv_content(input_path, max_rows=max_rows, max_cols=max_cols)

    if not content.rows:
        slides = [{"title": input_path.stem, "bullets": ["(empty file)"]}]
    else:
        slides = [{"title": input_path.stem, "bullets": [], "tables": [content.rows]}]

    write_pptx_from_slides(output_path, slides, title=input_path.stem)


def _csv_to_xlsx(input_path: Path, output_path: Path, max_rows: int, max_cols: int) -> None:
    """Convert CSV to XLSX: direct mapping."""
    content = read_csv_content(input_path, max_rows=max_rows, max_cols=max_cols)
    write_xlsx_from_sheets(output_path, [{"name": "Sheet1", "rows": content.rows}])


# --------------------------
# * -> CSV
# --------------------------

def _xlsx_to_csv(input_path: Path, output_path: Path, max_rows: int, max_cols: int) -> None:
    """Convert XLSX to CSV: export first sheet only, warn if multiple sheets."""
    content = read_xlsx_content(input_path, max_rows=max_rows, max_cols=max_cols)
    _print_warnings(content.warnings)

    if len(content.sheets) > 1:
        print(f"⚠️  Warning: XLSX has {len(content.sheets)} sheets, exporting only first sheet '{content.sheets[0].name}'", file=sys.stderr)

    if content.sheets:
        write_csv_from_rows(output_path, rows=content.sheets[0].cells)
    else:
        write_csv_from_rows(output_path, rows=[])


def _docx_to_csv(input_path: Path, output_path: Path, max_chars: int) -> None:
    """Convert DOCX to CSV: extract tables only (text content lost)."""
    import sys
    content = read_docx_content(input_path, max_chars=max_chars)

    if not content.tables:
        print(f"⚠️  Warning: No tables found in DOCX, CSV will be empty", file=sys.stderr)
        write_csv_from_rows(output_path, rows=[])
    else:
        # Export first table only
        if len(content.tables) > 1:
            print(f"⚠️  Warning: DOCX has {len(content.tables)} tables, exporting only first table", file=sys.stderr)
        write_csv_from_rows(output_path, rows=content.tables[0].rows)


def _pptx_to_csv(input_path: Path, output_path: Path, max_chars: int) -> None:
    """Convert PPTX to CSV: extract tables only (text content lost)."""
    import sys
    content = read_pptx_content(input_path, max_chars=max_chars)

    # Collect all tables from all slides
    all_tables: List[List[List[str]]] = []
    for slide in content.slides:
        all_tables.extend(slide.tables)

    if not all_tables:
        print(f"⚠️  Warning: No tables found in PPTX, CSV will be empty", file=sys.stderr)
        write_csv_from_rows(output_path, rows=[])
    else:
        # Export first table only
        if len(all_tables) > 1:
            print(f"⚠️  Warning: PPTX has {len(all_tables)} tables, exporting only first table", file=sys.stderr)
        write_csv_from_rows(output_path, rows=all_tables[0])


# --------------------------
# MD -> *
# --------------------------

def _md_to_docx(input_path: Path, output_path: Path, max_chars: int) -> None:
    """Convert Markdown to DOCX with semantic mapping."""
    content = read_md_content(input_path, max_chars=max_chars)
    doc = DocxDocument()

    # Add title if present
    if content.title:
        doc.add_heading(content.title, level=1)

    for section in content.sections:
        section_type = section.get('type')

        if section_type == 'heading':
            level = min(section.get('level', 1), 9)  # DOCX supports up to level 9
            doc.add_heading(section.get('text', ''), level=level)

        elif section_type == 'paragraph':
            doc.add_paragraph(section.get('text', ''))

        elif section_type == 'list':
            items = section.get('items', [])
            ordered = section.get('ordered', False)
            style = 'List Number' if ordered else 'List Bullet'
            for item in items:
                doc.add_paragraph(item, style=style)

        elif section_type == 'table':
            headers = section.get('headers', [])
            rows = section.get('rows', [])
            if headers or rows:
                all_rows = [headers] + rows if headers else rows
                if all_rows:
                    n_rows = len(all_rows)
                    n_cols = max((len(r) for r in all_rows), default=0)
                    table = doc.add_table(rows=n_rows, cols=n_cols)
                    for r_i, row in enumerate(all_rows):
                        for c_i in range(n_cols):
                            cell_value = row[c_i] if c_i < len(row) else ""
                            table.cell(r_i, c_i).text = str(cell_value)

        elif section_type == 'code':
            code = section.get('code', '')
            doc.add_paragraph(code, style='No Spacing')

    doc.save(str(output_path))


def _md_to_pptx(input_path: Path, output_path: Path, max_chars: int) -> None:
    """Convert Markdown to PPTX: each H2 starts new slide."""
    content = read_md_content(input_path, max_chars=max_chars)
    slides: List[dict] = []

    current_title = content.title or input_path.stem
    current_bullets: List[str] = []
    current_tables: List[List[List[str]]] = []

    def flush_slide():
        nonlocal current_title, current_bullets, current_tables
        if current_title or current_bullets or current_tables:
            slides.append({
                "title": current_title or "",
                "bullets": current_bullets[:],
                "tables": current_tables[:]
            })
        current_title = ""
        current_bullets = []
        current_tables = []

    for section in content.sections:
        section_type = section.get('type')

        if section_type == 'heading':
            level = section.get('level', 1)
            text = section.get('text', '')

            # H2 and above start new slides
            if level >= 2:
                flush_slide()
                current_title = text
            else:
                # H1 becomes a bullet
                current_bullets.append(f"# {text}")

        elif section_type == 'paragraph':
            text = section.get('text', '')
            if text:
                current_bullets.append(text)

        elif section_type == 'list':
            items = section.get('items', [])
            current_bullets.extend(items)

        elif section_type == 'table':
            headers = section.get('headers', [])
            rows = section.get('rows', [])
            table_rows = [headers] + rows if headers else rows
            if table_rows:
                current_tables.append(table_rows)

        elif section_type == 'code':
            code = section.get('code', '')
            current_bullets.append(f"Code: {code[:100]}...")

    flush_slide()

    if not slides:
        slides = [{"title": content.title or input_path.stem, "bullets": ["(empty document)"]}]

    write_pptx_from_slides(output_path, slides, title=content.title or input_path.stem)


def _md_to_xlsx(input_path: Path, output_path: Path, max_chars: int) -> None:
    """Convert Markdown to XLSX: sections as sheets."""
    content = read_md_content(input_path, max_chars=max_chars)
    sheets: List[dict] = []

    current_sheet_name = "Content"
    current_rows: List[List[str]] = []

    for section in content.sections:
        section_type = section.get('type')

        if section_type == 'heading':
            level = section.get('level', 1)
            text = section.get('text', '')

            # H1 and H2 become sheet names
            if level <= 2 and current_rows:
                sheets.append({"name": current_sheet_name[:31], "rows": current_rows[:]})
                current_sheet_name = text[:31]
                current_rows = []
            else:
                current_rows.append([f"{'#' * level} {text}"])

        elif section_type == 'paragraph':
            text = section.get('text', '')
            if text:
                current_rows.append([text])

        elif section_type == 'list':
            items = section.get('items', [])
            for item in items:
                current_rows.append([f"- {item}"])

        elif section_type == 'table':
            headers = section.get('headers', [])
            rows = section.get('rows', [])
            if headers:
                current_rows.append(headers)
            current_rows.extend(rows)

    if current_rows:
        sheets.append({"name": current_sheet_name[:31], "rows": current_rows})

    if not sheets:
        sheets = [{"name": "Sheet1", "rows": [["(empty document)"]]}]

    write_xlsx_from_sheets(output_path, sheets)


def _md_to_pdf(input_path: Path, output_path: Path, max_chars: int) -> None:
    """Convert Markdown to PDF via sections."""
    content = read_md_content(input_path, max_chars=max_chars)
    sections: List[dict] = []

    current_heading = ""
    current_paragraphs: List[str] = []
    current_tables: List[List[List[str]]] = []

    def flush_section():
        nonlocal current_heading, current_paragraphs, current_tables
        if current_heading or current_paragraphs or current_tables:
            sections.append({
                "heading": current_heading,
                "paragraphs": current_paragraphs[:],
                "tables": current_tables[:]
            })
        current_heading = ""
        current_paragraphs = []
        current_tables = []

    for section in content.sections:
        section_type = section.get('type')

        if section_type == 'heading':
            flush_section()
            current_heading = section.get('text', '')

        elif section_type == 'paragraph':
            text = section.get('text', '')
            if text:
                current_paragraphs.append(text)

        elif section_type == 'list':
            items = section.get('items', [])
            for item in items:
                current_paragraphs.append(f"• {item}")

        elif section_type == 'table':
            headers = section.get('headers', [])
            rows = section.get('rows', [])
            table_rows = [headers] + rows if headers else rows
            if table_rows:
                current_tables.append(table_rows)

        elif section_type == 'code':
            code = section.get('code', '')
            current_paragraphs.append(f"[Code Block]\n{code}")

    flush_section()

    if not sections:
        sections = [{"heading": content.title or input_path.stem, "paragraphs": ["(empty document)"], "tables": []}]

    write_pdf_from_sections(output_path, title=content.title or input_path.stem, sections=sections)


def _md_to_txt(input_path: Path, output_path: Path, max_chars: int) -> None:
    """Convert Markdown to plain text: preserve markdown syntax."""
    content = read_md_content(input_path, max_chars=max_chars)
    lines: List[str] = []

    if content.title:
        lines.append(f"# {content.title}")
        lines.append("")

    for section in content.sections:
        section_type = section.get('type')

        if section_type == 'heading':
            level = section.get('level', 1)
            text = section.get('text', '')
            lines.append(f"{'#' * level} {text}")
            lines.append("")

        elif section_type == 'paragraph':
            text = section.get('text', '')
            if text:
                lines.append(text)
                lines.append("")

        elif section_type == 'list':
            items = section.get('items', [])
            ordered = section.get('ordered', False)
            for idx, item in enumerate(items, start=1):
                prefix = f"{idx}." if ordered else "-"
                lines.append(f"{prefix} {item}")
            lines.append("")

        elif section_type == 'table':
            headers = section.get('headers', [])
            rows = section.get('rows', [])
            if headers:
                lines.append('| ' + ' | '.join(headers) + ' |')
                lines.append('| ' + ' | '.join(['---'] * len(headers)) + ' |')
            for row in rows:
                padded = row + [''] * (len(headers) - len(row)) if headers else row
                lines.append('| ' + ' | '.join(str(c) for c in padded) + ' |')
            lines.append("")

        elif section_type == 'code':
            lang = section.get('language', '')
            code = section.get('code', '')
            lines.append(f"```{lang}")
            lines.append(code)
            lines.append("```")
            lines.append("")

    write_txt_from_lines(output_path, lines)


# --------------------------
# * -> MD
# --------------------------

def _docx_to_md(input_path: Path, output_path: Path, max_chars: int) -> None:
    """Convert DOCX to Markdown with structure preservation."""
    content = read_docx_content(input_path, max_chars=max_chars)
    sections: List[dict] = []
    heading_set = set(content.headings)

    for para in content.paragraphs:
        if para in heading_set:
            sections.append({'type': 'heading', 'level': 2, 'text': para})
        else:
            sections.append({'type': 'paragraph', 'text': para})

    # Add tables
    for table in content.tables:
        if table.rows:
            sections.append({
                'type': 'table',
                'headers': table.rows[0] if table.rows else [],
                'rows': table.rows[1:] if len(table.rows) > 1 else []
            })

    write_md_from_sections(output_path, sections, title=input_path.stem)


def _txt_to_md(input_path: Path, output_path: Path, max_chars: int) -> None:
    """Convert plain text to Markdown: lines become paragraphs."""
    content = read_txt_content(input_path, max_chars=max_chars)
    sections: List[dict] = []

    for line in content.lines:
        if line.strip():
            sections.append({'type': 'paragraph', 'text': line})

    write_md_from_sections(output_path, sections, title=input_path.stem)


def _pdf_to_md(input_path: Path, output_path: Path, max_pages: int, max_chars: int) -> None:
    """Convert PDF to Markdown: pages as sections."""
    pdf = read_pdf_text(input_path, max_pages=max_pages, max_chars=max_chars)
    sections: List[dict] = []

    for i, page_text in enumerate(pdf.pages, start=1):
        sections.append({'type': 'heading', 'level': 2, 'text': f"Page {i}"})
        for line in page_text.splitlines():
            if line.strip():
                sections.append({'type': 'paragraph', 'text': line})

    write_md_from_sections(output_path, sections, title=input_path.stem)


def _pptx_to_md(input_path: Path, output_path: Path, max_chars: int) -> None:
    """Convert PPTX to Markdown: slides as sections."""
    content = read_pptx_content(input_path, max_chars=max_chars)
    sections: List[dict] = []

    for slide in content.slides:
        if slide.title:
            sections.append({'type': 'heading', 'level': 2, 'text': slide.title})

        # Add text as list items
        if slide.texts:
            sections.append({'type': 'list', 'ordered': False, 'items': slide.texts})

        # Add tables
        for table in slide.tables:
            if table:
                sections.append({
                    'type': 'table',
                    'headers': table[0] if table else [],
                    'rows': table[1:] if len(table) > 1 else []
                })

    write_md_from_sections(output_path, sections, title=input_path.stem)


def _xlsx_to_md(input_path: Path, output_path: Path, max_rows: int, max_cols: int) -> None:
    """Convert XLSX to Markdown: sheets as sections with tables."""
    content = read_xlsx_content(input_path, max_rows=max_rows, max_cols=max_cols)
    _print_warnings(content.warnings)
    sections: List[dict] = []

    for sheet in content.sheets:
        sections.append({'type': 'heading', 'level': 2, 'text': sheet.name})

        if sheet.cells:
            sections.append({
                'type': 'table',
                'headers': sheet.cells[0] if sheet.cells else [],
                'rows': sheet.cells[1:] if len(sheet.cells) > 1 else []
            })

    write_md_from_sections(output_path, sections, title=input_path.stem)


# --------------------------
# HTML -> *
# --------------------------

def _html_to_docx(input_path: Path, output_path: Path, max_chars: int) -> None:
    """Convert HTML to DOCX: semantic structure preserved."""
    content = read_html_content(input_path, max_chars=max_chars)
    doc = DocxDocument()

    for section in content.sections:
        section_type = section.get('type')

        if section_type == 'heading':
            level = min(section.get('level', 1), 6)
            text = section.get('text', '')
            para = doc.add_paragraph(text, style=f'Heading {level}')

        elif section_type == 'paragraph':
            text = section.get('text', '')
            if text:
                doc.add_paragraph(text)

        elif section_type == 'list':
            items = section.get('items', [])
            for item in items:
                doc.add_paragraph(item, style='List Bullet')

        elif section_type == 'table':
            headers = section.get('headers', [])
            rows = section.get('rows', [])

            if headers or rows:
                num_cols = len(headers) if headers else (len(rows[0]) if rows else 1)
                num_rows = (1 if headers else 0) + len(rows)

                table = doc.add_table(rows=num_rows, cols=num_cols)
                table.style = 'Light Grid Accent 1'

                row_idx = 0
                if headers:
                    for col_idx, header in enumerate(headers):
                        table.cell(row_idx, col_idx).text = str(header)
                    row_idx += 1

                for row_data in rows:
                    for col_idx, cell_value in enumerate(row_data):
                        if col_idx < num_cols:
                            table.cell(row_idx, col_idx).text = str(cell_value)
                    row_idx += 1

        elif section_type == 'code':
            code = section.get('code', '')
            if code:
                para = doc.add_paragraph(code)
                para.style = 'No Spacing'

    doc.save(str(output_path))


def _html_to_pptx(input_path: Path, output_path: Path, max_chars: int) -> None:
    """Convert HTML to PPTX: headings as slide titles."""
    content = read_html_content(input_path, max_chars=max_chars)

    slides = []
    current_slide = {'title': content.title or input_path.stem, 'bullets': [], 'tables': []}

    for section in content.sections:
        section_type = section.get('type')

        if section_type == 'heading':
            # Start new slide on H2 or higher
            if section.get('level', 1) <= 2:
                if current_slide['bullets'] or current_slide['tables']:
                    slides.append(current_slide)
                current_slide = {'title': section.get('text', ''), 'bullets': [], 'tables': []}

        elif section_type == 'paragraph':
            text = section.get('text', '')
            if text:
                current_slide['bullets'].append(text)

        elif section_type == 'list':
            items = section.get('items', [])
            current_slide['bullets'].extend(items)

        elif section_type == 'table':
            headers = section.get('headers', [])
            rows = section.get('rows', [])
            if headers or rows:
                table_data = [headers] + rows if headers else rows
                current_slide['tables'].append(table_data)

    if current_slide['bullets'] or current_slide['tables']:
        slides.append(current_slide)

    if not slides:
        slides = [{'title': content.title or input_path.stem, 'bullets': ['(No content)'], 'tables': []}]

    write_pptx_from_slides(output_path, slides)


def _html_to_xlsx(input_path: Path, output_path: Path, max_chars: int) -> None:
    """Convert HTML to XLSX: tables to sheets."""
    content = read_html_content(input_path, max_chars=max_chars)

    sheets = []
    table_count = 0

    for section in content.sections:
        if section.get('type') == 'table':
            table_count += 1
            headers = section.get('headers', [])
            rows = section.get('rows', [])

            if headers or rows:
                cells = [headers] + rows if headers else rows
                sheets.append({
                    'name': f'Table{table_count}',
                    'cells': cells
                })

    if not sheets:
        # Create a sheet with document title
        sheets = [{
            'name': 'Content',
            'cells': [[content.title or input_path.stem]]
        }]

    write_xlsx_from_sheets(output_path, sheets)


def _html_to_pdf(input_path: Path, output_path: Path, max_chars: int) -> None:
    """Convert HTML to PDF via sections."""
    content = read_html_content(input_path, max_chars=max_chars)
    write_pdf_from_sections(output_path, content.sections, title=content.title)


def _html_to_txt(input_path: Path, output_path: Path, max_chars: int) -> None:
    """Convert HTML to plain text."""
    content = read_html_content(input_path, max_chars=max_chars)
    lines = []

    if content.title:
        lines.append(content.title)
        lines.append('=' * len(content.title))
        lines.append('')

    for section in content.sections:
        section_type = section.get('type')

        if section_type == 'heading':
            level = section.get('level', 1)
            text = section.get('text', '')
            prefix = '#' * level
            lines.append(f"{prefix} {text}")
            lines.append('')

        elif section_type == 'paragraph':
            text = section.get('text', '')
            if text:
                lines.append(text)
                lines.append('')

        elif section_type == 'list':
            items = section.get('items', [])
            for item in items:
                lines.append(f"• {item}")
            lines.append('')

        elif section_type == 'table':
            headers = section.get('headers', [])
            rows = section.get('rows', [])

            if headers:
                lines.append(' | '.join(headers))
                lines.append('-' * 40)

            for row in rows:
                lines.append(' | '.join(str(cell) for cell in row))

            lines.append('')

        elif section_type == 'code':
            code = section.get('code', '')
            lines.append(code)
            lines.append('')

    write_txt_from_lines(output_path, lines)


def _html_to_csv(input_path: Path, output_path: Path, max_chars: int) -> None:
    """Convert HTML to CSV: first table only."""
    content = read_html_content(input_path, max_chars=max_chars)

    for section in content.sections:
        if section.get('type') == 'table':
            headers = section.get('headers', [])
            rows = section.get('rows', [])

            write_csv_from_rows(output_path, rows, headers=headers if headers else None)
            return

    # No tables found, create a simple CSV
    write_csv_from_rows(output_path, [[content.title or input_path.stem]])


def _html_to_md(input_path: Path, output_path: Path, max_chars: int) -> None:
    """Convert HTML to Markdown: direct section mapping."""
    content = read_html_content(input_path, max_chars=max_chars)
    write_md_from_sections(output_path, content.sections, title=content.title)


# --------------------------
# * -> HTML
# --------------------------

def _md_to_html(input_path: Path, output_path: Path, max_chars: int) -> None:
    """Convert Markdown to HTML: direct section mapping."""
    content = read_md_content(input_path, max_chars=max_chars)
    write_html_from_sections(output_path, content.sections, title=content.title)


def _docx_to_html(input_path: Path, output_path: Path, max_chars: int) -> None:
    """Convert DOCX to HTML: paragraphs and tables."""
    content = read_docx_content(input_path, max_chars=max_chars)
    sections: List[dict] = []

    # Add headings
    for heading in content.headings:
        sections.append({'type': 'heading', 'level': 2, 'text': heading})

    # Add paragraphs
    for para in content.paragraphs:
        if para.strip():
            sections.append({'type': 'paragraph', 'text': para})

    # Add tables
    for table in content.tables:
        if table.cells:
            sections.append({
                'type': 'table',
                'headers': table.cells[0] if table.cells else [],
                'rows': table.cells[1:] if len(table.cells) > 1 else []
            })

    write_html_from_sections(output_path, sections, title=input_path.stem)


def _txt_to_html(input_path: Path, output_path: Path, max_chars: int) -> None:
    """Convert plain text to HTML: lines as paragraphs."""
    content = read_txt_content(input_path, max_chars=max_chars)
    sections: List[dict] = []

    for line in content.lines:
        if line.strip():
            sections.append({'type': 'paragraph', 'text': line})

    write_html_from_sections(output_path, sections, title=input_path.stem)


def _pdf_to_html(input_path: Path, output_path: Path, max_pages: int, max_chars: int) -> None:
    """Convert PDF to HTML: pages as sections."""
    pdf = read_pdf_text(input_path, max_pages=max_pages, max_chars=max_chars)
    sections: List[dict] = []

    for i, page_text in enumerate(pdf.pages, start=1):
        sections.append({'type': 'heading', 'level': 2, 'text': f"Page {i}"})
        for line in page_text.splitlines():
            if line.strip():
                sections.append({'type': 'paragraph', 'text': line})

    write_html_from_sections(output_path, sections, title=input_path.stem)


def _pptx_to_html(input_path: Path, output_path: Path, max_chars: int) -> None:
    """Convert PPTX to HTML: slides as sections."""
    content = read_pptx_content(input_path, max_chars=max_chars)
    sections: List[dict] = []

    for slide in content.slides:
        if slide.title:
            sections.append({'type': 'heading', 'level': 2, 'text': slide.title})

        # Add text as list items
        if slide.texts:
            sections.append({'type': 'list', 'ordered': False, 'items': slide.texts})

        # Add tables
        for table in slide.tables:
            if table:
                sections.append({
                    'type': 'table',
                    'headers': table[0] if table else [],
                    'rows': table[1:] if len(table) > 1 else []
                })

    write_html_from_sections(output_path, sections, title=input_path.stem)


def _xlsx_to_html(input_path: Path, output_path: Path, max_rows: int, max_cols: int) -> None:
    """Convert XLSX to HTML: sheets as sections with tables."""
    content = read_xlsx_content(input_path, max_rows=max_rows, max_cols=max_cols)
    _print_warnings(content.warnings)
    sections: List[dict] = []

    for sheet in content.sheets:
        sections.append({'type': 'heading', 'level': 2, 'text': sheet.name})

        if sheet.cells:
            sections.append({
                'type': 'table',
                'headers': sheet.cells[0] if sheet.cells else [],
                'rows': sheet.cells[1:] if len(sheet.cells) > 1 else []
            })

    write_html_from_sections(output_path, sections, title=input_path.stem)


def _csv_to_html(input_path: Path, output_path: Path, max_rows: int, max_cols: int) -> None:
    """Convert CSV to HTML: data as table."""
    content = read_csv_content(input_path, max_rows=max_rows, max_cols=max_cols)
    sections: List[dict] = []

    headers = content.headers if content.has_header else []
    rows = content.rows

    # If has_header, the first row is already in headers, so use remaining rows
    if content.has_header and rows:
        rows = rows

    sections.append({
        'type': 'table',
        'headers': headers,
        'rows': rows
    })

    write_html_from_sections(output_path, sections, title=input_path.stem)