mdify-cli 1.2.0__tar.gz → 1.6.0__tar.gz

{mdify_cli-1.2.0/mdify_cli.egg-info → mdify_cli-1.6.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: mdify-cli
-Version: 1.2.0
-Summary: Lightweight CLI for converting documents to Markdown via Docling container
+Version: 1.6.0
+Summary: Convert PDFs and document images into structured Markdown for LLM workflows
 Author: tiroq
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/tiroq/mdify
@@ -24,11 +24,19 @@ Classifier: Topic :: Utilities
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
 Dynamic: license-file
 
 # mdify
 
-A lightweight CLI for converting documents to Markdown. The CLI is fast to install via pipx, while the heavy ML conversion (Docling) runs inside a container.
+![mdify banner](https://raw.githubusercontent.com/tiroq/mdify/main/assets/mdify.png)
+
+[![PyPI](https://img.shields.io/pypi/v/mdify-cli?logo=python&style=flat-square)](https://pypi.org/project/mdify-cli/)
+[![Container](https://img.shields.io/badge/container-ghcr.io-blue?logo=docker&style=flat-square)](https://github.com/tiroq/mdify/pkgs/container/mdify-runtime)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](https://opensource.org/licenses/MIT)
+
+A lightweight CLI for converting documents to Markdown. The CLI is fast to install via pipx, while the heavy ML conversion runs inside a container.
 
 ## Requirements
 

{mdify_cli-1.2.0 → mdify_cli-1.6.0}/README.md

@@ -1,6 +1,12 @@
 # mdify
 
-A lightweight CLI for converting documents to Markdown. The CLI is fast to install via pipx, while the heavy ML conversion (Docling) runs inside a container.
+![mdify banner](https://raw.githubusercontent.com/tiroq/mdify/main/assets/mdify.png)
+
+[![PyPI](https://img.shields.io/pypi/v/mdify-cli?logo=python&style=flat-square)](https://pypi.org/project/mdify-cli/)
+[![Container](https://img.shields.io/badge/container-ghcr.io-blue?logo=docker&style=flat-square)](https://github.com/tiroq/mdify/pkgs/container/mdify-runtime)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](https://opensource.org/licenses/MIT)
+
+A lightweight CLI for converting documents to Markdown. The CLI is fast to install via pipx, while the heavy ML conversion runs inside a container.
 
 ## Requirements
 

{mdify_cli-1.2.0 → mdify_cli-1.6.0}/mdify/__init__.py

@@ -1,3 +1,3 @@
 """mdify - Convert documents to Markdown via Docling container."""
 
-__version__ = "1.2.0"
+__version__ = "1.6.0"

{mdify_cli-1.2.0 → mdify_cli-1.6.0}/mdify/cli.py

@@ -13,6 +13,7 @@ import os
 import shutil
 import subprocess
 import sys
+import threading
 import time
 from pathlib import Path
 from typing import List, Optional, Tuple
@@ -24,8 +25,7 @@ from . import __version__
 # Configuration
 MDIFY_HOME = Path.home() / ".mdify"
 LAST_CHECK_FILE = MDIFY_HOME / ".last_check"
-INSTALLER_PATH = MDIFY_HOME / "install.sh"
-GITHUB_API_URL = "https://api.github.com/repos/tiroq/mdify/releases/latest"
+PYPI_API_URL = "https://pypi.org/pypi/mdify-cli/json"
 CHECK_INTERVAL_SECONDS = 86400  # 24 hours
 
 # Container configuration
@@ -37,18 +37,19 @@ SUPPORTED_RUNTIMES = ("docker", "podman")
 # Update checking functions
 # =============================================================================
 
+
 def _get_remote_version(timeout: int = 5) -> Optional[str]:
     """
-    Fetch the latest version from GitHub API.
-    
+    Fetch the latest version from PyPI.
+
     Returns:
-        Version string (e.g., "0.2.0") or None if fetch failed.
+        Version string (e.g., "1.1.0") or None if fetch failed.
     """
     try:
-        with urlopen(GITHUB_API_URL, timeout=timeout) as response:
+        with urlopen(PYPI_API_URL, timeout=timeout) as response:
             data = json.loads(response.read().decode("utf-8"))
-            tag = data.get("tag_name", "")
-            return tag.lstrip("v") if tag else None
+            version = data.get("info", {}).get("version", "")
+            return version if version else None
     except (URLError, json.JSONDecodeError, KeyError, TimeoutError):
         return None
 
@@ -56,16 +57,16 @@ def _get_remote_version(timeout: int = 5) -> Optional[str]:
 def _should_check_for_update() -> bool:
     """
     Determine if we should check for updates based on last check time.
-    
+
     Returns:
         True if check should be performed, False otherwise.
     """
     if os.environ.get("MDIFY_NO_UPDATE_CHECK", "").lower() in ("1", "true", "yes"):
         return False
-    
+
     if not LAST_CHECK_FILE.exists():
         return True
-    
+
     try:
         last_check = float(LAST_CHECK_FILE.read_text().strip())
         elapsed = time.time() - last_check
@@ -86,63 +87,35 @@ def _update_last_check_time() -> None:
 def _compare_versions(current: str, remote: str) -> bool:
     """
     Compare version strings.
-    
+
     Returns:
         True if remote version is newer than current.
     """
     try:
         current_parts = [int(x) for x in current.split(".")]
         remote_parts = [int(x) for x in remote.split(".")]
-        
+
         max_len = max(len(current_parts), len(remote_parts))
         current_parts.extend([0] * (max_len - len(current_parts)))
         remote_parts.extend([0] * (max_len - len(remote_parts)))
-        
+
         return remote_parts > current_parts
     except (ValueError, AttributeError):
         return False
 
 
-def _run_upgrade() -> bool:
-    """
-    Run the upgrade installer.
-    
-    Returns:
-        True if upgrade was successful, False otherwise.
-    """
-    if not INSTALLER_PATH.exists():
-        print(
-            f"Installer not found at {INSTALLER_PATH}. "
-            "Please reinstall mdify manually.",
-            file=sys.stderr,
-        )
-        return False
-    
-    try:
-        result = subprocess.run(
-            [str(INSTALLER_PATH), "--upgrade", "-y"],
-            check=True,
-        )
-        return result.returncode == 0
-    except subprocess.CalledProcessError:
-        return False
-    except OSError as e:
-        print(f"Failed to run installer: {e}", file=sys.stderr)
-        return False
-
-
 def check_for_update(force: bool = False) -> None:
     """
     Check for updates and prompt user to upgrade if available.
-    
+
     Args:
         force: If True, check regardless of last check time and show errors.
     """
     if not force and not _should_check_for_update():
         return
-    
+
     remote_version = _get_remote_version()
-    
+
     if remote_version is None:
         if force:
             print(
@@ -152,49 +125,40 @@ def check_for_update(force: bool = False) -> None:
             )
             sys.exit(1)
         return
-    
+
     _update_last_check_time()
-    
+
     if not _compare_versions(__version__, remote_version):
         if force:
             print(f"mdify is up to date (version {__version__})")
         return
-    
-    print(f"\n{'='*50}")
-    print(f"A new version of mdify is available!")
+
+    print(f"\n{'=' * 50}")
+    print(f"A new version of mdify-cli is available!")
     print(f"  Current version: {__version__}")
     print(f"  Latest version:  {remote_version}")
-    print(f"{'='*50}\n")
-    
-    try:
-        response = input("Run upgrade now? [y/N] ").strip().lower()
-    except (EOFError, KeyboardInterrupt):
-        print()
-        return
-    
-    if response in ("y", "yes"):
-        print("\nStarting upgrade...\n")
-        if _run_upgrade():
-            print("\nUpgrade completed! Please restart mdify.")
-            sys.exit(0)
-        else:
-            print("\nUpgrade failed. You can try manually with:")
-            print(f"  {INSTALLER_PATH} --upgrade")
-    else:
-        print(f"\nTo upgrade later, run: {INSTALLER_PATH} --upgrade\n")
+    print(f"{'=' * 50}")
+    print(f"\nTo upgrade, run:")
+    print(f"  pipx upgrade mdify-cli")
+    print(f"  # or: pip install --upgrade mdify-cli\n")
 
 
 # =============================================================================
 # Container runtime functions
 # =============================================================================
 
-def detect_runtime(preferred: str) -> Optional[str]:
+
+def detect_runtime(preferred: str, explicit: bool = True) -> Optional[str]:
     """
     Detect available container runtime.
-    
+
     Args:
         preferred: Preferred runtime ('docker' or 'podman')
-        
+        explicit: If True, warn when falling back to alternative.
+                  If False, silently use alternative without warning.
+                  Note: This only controls warning emission; selection order
+                  is always preferred → alternative regardless of this flag.
+
     Returns:
         Path to runtime executable, or None if not found.
     """
@@ -202,25 +166,28 @@ def detect_runtime(preferred: str) -> Optional[str]:
     runtime_path = shutil.which(preferred)
     if runtime_path:
         return runtime_path
-    
+
     # Try alternative
     alternative = "podman" if preferred == "docker" else "docker"
     runtime_path = shutil.which(alternative)
     if runtime_path:
-        print(f"Warning: {preferred} not found, using {alternative}", file=sys.stderr)
+        if explicit:
+            print(
+                f"Warning: {preferred} not found, using {alternative}", file=sys.stderr
+            )
         return runtime_path
-    
+
     return None
 
 
 def check_image_exists(runtime: str, image: str) -> bool:
     """
     Check if container image exists locally.
-    
+
     Args:
         runtime: Path to container runtime
         image: Image name/tag
-        
+
     Returns:
         True if image exists locally.
     """
@@ -238,18 +205,18 @@ def check_image_exists(runtime: str, image: str) -> bool:
 def pull_image(runtime: str, image: str, quiet: bool = False) -> bool:
     """
     Pull container image.
-    
+
     Args:
         runtime: Path to container runtime
         image: Image name/tag
         quiet: Suppress progress output
-        
+
     Returns:
         True if pull succeeded.
     """
     if not quiet:
         print(f"Pulling image: {image}")
-    
+
     try:
         result = subprocess.run(
             [runtime, "pull", image],
@@ -262,51 +229,116 @@ def pull_image(runtime: str, image: str, quiet: bool = False) -> bool:
         return False
 
 
+def format_size(size_bytes: int) -> str:
+    """Format file size in human-readable format."""
+    for unit in ["B", "KB", "MB", "GB"]:
+        if size_bytes < 1024:
+            return f"{size_bytes:.1f} {unit}" if unit != "B" else f"{size_bytes} {unit}"
+        size_bytes /= 1024
+    return f"{size_bytes:.1f} TB"
+
+
+def format_duration(seconds: float) -> str:
+    """Format duration in human-readable format."""
+    if seconds < 60:
+        return f"{seconds:.1f}s"
+    minutes = int(seconds // 60)
+    secs = seconds % 60
+    if minutes < 60:
+        return f"{minutes}m {secs:.0f}s"
+    hours = minutes // 60
+    mins = minutes % 60
+    return f"{hours}h {mins}m {secs:.0f}s"
+
+
+class Spinner:
+    """A simple spinner to show progress during long operations."""
+
+    def __init__(self):
+        self.frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+        self.running = False
+        self.thread = None
+        self.start_time = None
+
+    def _spin(self):
+        idx = 0
+        while self.running:
+            elapsed = time.time() - self.start_time
+            frame = self.frames[idx % len(self.frames)]
+            print(
+                f"\r{self.prefix} {frame} ({format_duration(elapsed)})",
+                end="",
+                flush=True,
+            )
+            idx += 1
+            time.sleep(0.1)
+
+    def start(self, prefix: str = ""):
+        self.prefix = prefix
+        self.running = True
+        self.start_time = time.time()
+        self.thread = threading.Thread(target=self._spin, daemon=True)
+        self.thread.start()
+
+    def stop(self):
+        self.running = False
+        if self.thread:
+            self.thread.join(timeout=0.5)
+        # Clear the spinner line
+        print(f"\r{' ' * 80}\r", end="", flush=True)
+
+
 def run_container(
     runtime: str,
     image: str,
     input_file: Path,
     output_file: Path,
     mask_pii: bool = False,
-    quiet: bool = False,
-) -> Tuple[bool, str]:
+) -> Tuple[bool, str, float]:
     """
     Run container to convert a single file.
-    
+
     Args:
         runtime: Path to container runtime
         image: Image name/tag
         input_file: Absolute path to input file
         output_file: Absolute path to output file
         mask_pii: Whether to mask PII in images
-        quiet: Suppress progress output
-        
+
     Returns:
-        Tuple of (success: bool, message: str)
+        Tuple of (success: bool, message: str, elapsed_seconds: float)
     """
+    start_time = time.time()
+
     # Ensure output directory exists
     output_file.parent.mkdir(parents=True, exist_ok=True)
-    
+
     # Mount directories
     input_dir = input_file.parent
     output_dir = output_file.parent
-    
+
     # Container paths
     container_in = f"/work/in/{input_file.name}"
     container_out = f"/work/out/{output_file.name}"
-    
+
     cmd = [
-        runtime, "run", "--rm",
-        "-v", f"{input_dir}:/work/in:ro",
-        "-v", f"{output_dir}:/work/out",
+        runtime,
+        "run",
+        "--rm",
+        "-v",
+        f"{input_dir}:/work/in:ro",
+        "-v",
+        f"{output_dir}:/work/out",
         image,
-        "--in", container_in,
-        "--out", container_out,
+        "--in",
+        container_in,
+        "--out",
+        container_out,
     ]
-    
+
     if mask_pii:
         cmd.append("--mask")
-    
+
     try:
         result = subprocess.run(
             cmd,
@@ -314,21 +346,19 @@ def run_container(
             text=True,
             check=False,
         )
-        
+        elapsed = time.time() - start_time
+
         if result.returncode == 0:
-            if not quiet:
-                print(f"Converted: {input_file} -> {output_file}")
-            return True, "success"
+            return True, "success", elapsed
         else:
-            error_msg = result.stderr.strip() or result.stdout.strip() or "Unknown error"
-            if not quiet:
-                print(f"Failed: {input_file} - {error_msg}", file=sys.stderr)
-            return False, f"error: {error_msg}"
-            
+            error_msg = (
+                result.stderr.strip() or result.stdout.strip() or "Unknown error"
+            )
+            return False, error_msg, elapsed
+
     except OSError as e:
-        if not quiet:
-            print(f"Failed: {input_file} - {e}", file=sys.stderr)
-        return False, f"error: {e}"
+        elapsed = time.time() - start_time
+        return False, str(e), elapsed
 
 
 # =============================================================================
@@ -337,22 +367,39 @@ def run_container(
 
 # Supported file extensions (based on Docling InputFormat)
 SUPPORTED_EXTENSIONS = {
-    '.pdf', '.docx', '.pptx', '.html', '.htm',
-    '.png', '.jpg', '.jpeg', '.gif', '.bmp', '.tiff', '.tif',  # images
-    '.asciidoc', '.adoc', '.asc',  # asciidoc
-    '.md', '.markdown',  # markdown
-    '.csv', '.xlsx',  # spreadsheets
-    '.xml',  # XML formats
-    '.json',  # JSON docling
-    '.mp3', '.wav', '.m4a', '.flac',  # audio
-    '.vtt',  # subtitles
+    ".pdf",
+    ".docx",
+    ".pptx",
+    ".html",
+    ".htm",
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".bmp",
+    ".tiff",
+    ".tif",  # images
+    ".asciidoc",
+    ".adoc",
+    ".asc",  # asciidoc
+    ".md",
+    ".markdown",  # markdown
+    ".csv",
+    ".xlsx",  # spreadsheets
+    ".xml",  # XML formats
+    ".json",  # JSON docling
+    ".mp3",
+    ".wav",
+    ".m4a",
+    ".flac",  # audio
+    ".vtt",  # subtitles
 }
 
 
 def get_files_to_convert(input_path: Path, mask: str, recursive: bool) -> List[Path]:
     """Get list of files to convert based on input path and options."""
     files = []
-    
+
     if input_path.is_file():
         files.append(input_path)
     elif input_path.is_dir():
@@ -360,19 +407,19 @@ def get_files_to_convert(input_path: Path, mask: str, recursive: bool) -> List[P
             files = list(input_path.rglob(mask))
         else:
             files = list(input_path.glob(mask))
-        
+
         # Filter to only files
         files = [f for f in files if f.is_file()]
     else:
         raise FileNotFoundError(f"Input path does not exist: {input_path}")
-    
+
     # Filter out hidden files and unsupported formats
     files = [
-        f for f in files
-        if not f.name.startswith('.')
-        and f.suffix.lower() in SUPPORTED_EXTENSIONS
+        f
+        for f in files
+        if not f.name.startswith(".") and f.suffix.lower() in SUPPORTED_EXTENSIONS
     ]
-    
+
     return files
 
 
@@ -405,7 +452,7 @@ def get_output_path(
             output_path = output_dir / relative_path.parent / output_name
         except ValueError:
             output_path = output_dir / output_name
-        
+
         return output_path
 
 
@@ -413,6 +460,7 @@ def get_output_path(
 # CLI argument parsing
 # =============================================================================
 
+
 def parse_args() -> argparse.Namespace:
     """Parse command line arguments."""
     parser = argparse.ArgumentParser(
@@ -427,74 +475,79 @@ Examples:
   mdify ./docs --runtime podman          Use Podman instead of Docker
 """,
     )
-    
+
     parser.add_argument(
         "input",
         type=str,
         nargs="?",
         help="Input file or directory to convert",
     )
-    
+
     parser.add_argument(
-        "-o", "--out-dir",
+        "-o",
+        "--out-dir",
         type=str,
         default="output",
         help="Output directory for converted files (default: output)",
     )
-    
+
     parser.add_argument(
-        "-g", "--glob",
+        "-g",
+        "--glob",
         type=str,
         default="*",
         help="Glob pattern for filtering files in directory (default: *)",
     )
-    
+
     parser.add_argument(
-        "-r", "--recursive",
+        "-r",
+        "--recursive",
         action="store_true",
         help="Recursively scan directories",
     )
-    
+
     parser.add_argument(
         "--flat",
         action="store_true",
         help="Disable directory structure preservation in output",
     )
-    
+
     parser.add_argument(
         "--overwrite",
         action="store_true",
         help="Overwrite existing output files",
     )
-    
+
     parser.add_argument(
-        "-q", "--quiet",
+        "-q",
+        "--quiet",
         action="store_true",
         help="Suppress progress messages",
     )
-    
+
     parser.add_argument(
-        "-m", "--mask",
+        "-m",
+        "--mask",
         action="store_true",
         help="Mask PII and sensitive content in document images",
     )
-    
+
     # Container options
     parser.add_argument(
         "--runtime",
         type=str,
         choices=SUPPORTED_RUNTIMES,
-        default="docker",
-        help="Container runtime to use (default: docker)",
+        default=None,
+        help="Container runtime to use (auto-detects docker or podman if not specified)",
     )
-    
+
     parser.add_argument(
         "--image",
         type=str,
         default=DEFAULT_IMAGE,
         help=f"Container image to use (default: {DEFAULT_IMAGE})",
     )
-    
+
     parser.add_argument(
         "--pull",
         type=str,
@@ -502,20 +555,20 @@ Examples:
         default="missing",
         help="Image pull policy: always, missing, never (default: missing)",
     )
-    
+
     # Utility options
     parser.add_argument(
         "--check-update",
         action="store_true",
         help="Check for available updates and exit",
     )
-    
+
     parser.add_argument(
         "--version",
         action="version",
         version=f"mdify {__version__}",
     )
-    
+
     return parser.parse_args()
 
 
@@ -523,27 +576,30 @@ Examples:
 # Main entry point
 # =============================================================================
 
+
 def main() -> int:
     """Main entry point for the CLI."""
     args = parse_args()
-    
+
     # Handle --check-update flag
     if args.check_update:
         check_for_update(force=True)
         return 0
-    
+
     # Check for updates (daily, silent on errors)
     check_for_update(force=False)
-    
+
     # Validate input is provided
     if args.input is None:
         print("Error: Input file or directory is required", file=sys.stderr)
         print("Usage: mdify <input> [options]", file=sys.stderr)
         print("       mdify --help for more information", file=sys.stderr)
         return 1
-    
+
     # Detect container runtime
-    runtime = detect_runtime(args.runtime)
+    preferred = args.runtime if args.runtime else "docker"
+    explicit = args.runtime is not None
+    runtime = detect_runtime(preferred, explicit=explicit)
     if runtime is None:
         print(
             f"Error: Container runtime not found ({', '.join(SUPPORTED_RUNTIMES)})",
@@ -551,87 +607,111 @@ def main() -> int:
         )
         print("Please install Docker or Podman to use mdify.", file=sys.stderr)
         return 2
-    
+
     # Handle image pull policy
     image = args.image
     image_exists = check_image_exists(runtime, image)
-    
+
     if args.pull == "always" or (args.pull == "missing" and not image_exists):
         if not pull_image(runtime, image, args.quiet):
             print(f"Error: Failed to pull image: {image}", file=sys.stderr)
             return 1
     elif args.pull == "never" and not image_exists:
         print(f"Error: Image not found locally: {image}", file=sys.stderr)
-        print(f"Run with --pull=missing or pull manually: {args.runtime} pull {image}")
+        print(f"Run with --pull=missing or pull manually: {preferred} pull {image}")
         return 1
-    
+
     # Resolve paths
     input_path = Path(args.input).resolve()
     output_dir = Path(args.out_dir).resolve()
-    
+
     # Validate input
     if not input_path.exists():
         print(f"Error: Input path does not exist: {input_path}", file=sys.stderr)
         return 1
-    
+
     # Get files to convert
     try:
         files_to_convert = get_files_to_convert(input_path, args.glob, args.recursive)
     except Exception as e:
         print(f"Error: {e}", file=sys.stderr)
         return 1
-    
+
     if not files_to_convert:
         print(f"No files found to convert in: {input_path}", file=sys.stderr)
         return 1
-    
+
+    total_files = len(files_to_convert)
+    total_size = sum(f.stat().st_size for f in files_to_convert)
+
     if not args.quiet:
-        print(f"Found {len(files_to_convert)} file(s) to convert")
+        print(f"Found {total_files} file(s) to convert ({format_size(total_size)})")
         print(f"Using runtime: {runtime}")
         print(f"Using image: {image}")
         print()
-    
+
     # Determine input base for directory structure preservation
     if input_path.is_file():
         input_base = input_path.parent
     else:
         input_base = input_path
-    
+
     # Convert files
     success_count = 0
     skipped_count = 0
     failed_count = 0
-    
-    for input_file in files_to_convert:
+    conversion_start = time.time()
+    spinner = Spinner()
+
+    for idx, input_file in enumerate(files_to_convert, 1):
         output_file = get_output_path(input_file, input_base, output_dir, args.flat)
-        
+        file_size = input_file.stat().st_size
+        progress = f"[{idx}/{total_files}]"
+
         # Check if output exists and skip if not overwriting
         if output_file.exists() and not args.overwrite:
             if not args.quiet:
-                print(f"Skipped (exists): {input_file} -> {output_file}")
+                print(f"{progress} Skipped (exists): {input_file.name}")
             skipped_count += 1
             continue
-        
-        success, result = run_container(
-            runtime, image, input_file, output_file, args.mask, args.quiet
+
+        # Show spinner while processing
+        if not args.quiet:
+            spinner.start(
+                f"{progress} Processing: {input_file.name} ({format_size(file_size)})"
+            )
+
+        success, result, elapsed = run_container(
+            runtime, image, input_file, output_file, args.mask
         )
-        
+
+        if not args.quiet:
+            spinner.stop()
+
         if success:
             success_count += 1
+            if not args.quiet:
+                print(f"{progress} {input_file.name} ✓ ({format_duration(elapsed)})")
         else:
             failed_count += 1
-    
+            if not args.quiet:
+                print(f"{progress} {input_file.name} ✗ ({format_duration(elapsed)})")
+                print(f"    Error: {result}", file=sys.stderr)
+
+    total_elapsed = time.time() - conversion_start
+
     # Print summary
     if not args.quiet:
         print()
         print("=" * 50)
         print("Conversion Summary:")
-        print(f"  Total files:     {len(files_to_convert)}")
+        print(f"  Total files:     {total_files}")
         print(f"  Successful:      {success_count}")
         print(f"  Skipped:         {skipped_count}")
         print(f"  Failed:          {failed_count}")
+        print(f"  Total time:      {format_duration(total_elapsed)}")
         print("=" * 50)
-    
+
     # Return appropriate exit code
     if failed_count > 0:
         return 1

{mdify_cli-1.2.0 → mdify_cli-1.6.0/mdify_cli.egg-info}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: mdify-cli
-Version: 1.2.0
-Summary: Lightweight CLI for converting documents to Markdown via Docling container
+Version: 1.6.0
+Summary: Convert PDFs and document images into structured Markdown for LLM workflows
 Author: tiroq
 License-Expression: MIT
 Project-URL: Homepage, https://github.com/tiroq/mdify
@@ -24,11 +24,19 @@ Classifier: Topic :: Utilities
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
 Dynamic: license-file
 
 # mdify
 
-A lightweight CLI for converting documents to Markdown. The CLI is fast to install via pipx, while the heavy ML conversion (Docling) runs inside a container.
+![mdify banner](https://raw.githubusercontent.com/tiroq/mdify/main/assets/mdify.png)
+
+[![PyPI](https://img.shields.io/pypi/v/mdify-cli?logo=python&style=flat-square)](https://pypi.org/project/mdify-cli/)
+[![Container](https://img.shields.io/badge/container-ghcr.io-blue?logo=docker&style=flat-square)](https://github.com/tiroq/mdify/pkgs/container/mdify-runtime)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](https://opensource.org/licenses/MIT)
+
+A lightweight CLI for converting documents to Markdown. The CLI is fast to install via pipx, while the heavy ML conversion runs inside a container.
 
 ## Requirements
 

{mdify_cli-1.2.0 → mdify_cli-1.6.0}/mdify_cli.egg-info/SOURCES.txt

@@ -4,8 +4,11 @@ pyproject.toml
 mdify/__init__.py
 mdify/__main__.py
 mdify/cli.py
+mdify/../assets/mdify.png
 mdify_cli.egg-info/PKG-INFO
 mdify_cli.egg-info/SOURCES.txt
 mdify_cli.egg-info/dependency_links.txt
 mdify_cli.egg-info/entry_points.txt
-mdify_cli.egg-info/top_level.txt
+mdify_cli.egg-info/requires.txt
+mdify_cli.egg-info/top_level.txt
+tests/test_cli.py

mdify_cli-1.6.0/mdify_cli.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[dev]
+pytest>=7.0

{mdify_cli-1.2.0 → mdify_cli-1.6.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "mdify-cli"
-version = "1.2.0"
-description = "Lightweight CLI for converting documents to Markdown via Docling container"
+version = "1.6.0"
+description = "Convert PDFs and document images into structured Markdown for LLM workflows"
 readme = "README.md"
 requires-python = ">=3.8"
 license = "MIT"
@@ -26,6 +26,9 @@ classifiers = [
 ]
 dependencies = []
 
+[project.optional-dependencies]
+dev = ["pytest>=7.0"]
+
 [project.urls]
 Homepage = "https://github.com/tiroq/mdify"
 Repository = "https://github.com/tiroq/mdify"
@@ -41,3 +44,6 @@ build-backend = "setuptools.build_meta"
 [tool.setuptools.packages.find]
 include = ["mdify", "mdify.*"]
 exclude = ["runtime", "runtime.*"]
+
+[tool.setuptools.package-data]
+mdify = ["../assets/*.png"]

mdify_cli-1.6.0/tests/test_cli.py

@@ -0,0 +1,77 @@
+"""Tests for mdify CLI runtime detection."""
+
+from unittest.mock import patch
+from mdify.cli import detect_runtime
+
+
+class TestDetectRuntime:
+    """Tests for detect_runtime() function."""
+
+    def test_auto_docker_exists(self):
+        with patch("mdify.cli.shutil.which") as mock_which:
+            mock_which.side_effect = (
+                lambda x: "/usr/bin/docker" if x == "docker" else None
+            )
+            result = detect_runtime("docker", explicit=False)
+            assert result == "/usr/bin/docker"
+
+    def test_auto_only_podman_exists(self, capsys):
+        with patch("mdify.cli.shutil.which") as mock_which:
+            mock_which.side_effect = (
+                lambda x: "/usr/bin/podman" if x == "podman" else None
+            )
+            result = detect_runtime("docker", explicit=False)
+            assert result == "/usr/bin/podman"
+            captured = capsys.readouterr()
+            assert captured.err == ""
+
+    def test_auto_neither_exists(self):
+        with patch("mdify.cli.shutil.which", return_value=None):
+            result = detect_runtime("docker", explicit=False)
+            assert result is None
+
+    def test_explicit_docker_exists(self):
+        with patch("mdify.cli.shutil.which") as mock_which:
+            mock_which.side_effect = (
+                lambda x: "/usr/bin/docker" if x == "docker" else None
+            )
+            result = detect_runtime("docker", explicit=True)
+            assert result == "/usr/bin/docker"
+
+    def test_explicit_docker_fallback_to_podman(self, capsys):
+        with patch("mdify.cli.shutil.which") as mock_which:
+            mock_which.side_effect = (
+                lambda x: "/usr/bin/podman" if x == "podman" else None
+            )
+            result = detect_runtime("docker", explicit=True)
+            assert result == "/usr/bin/podman"
+            captured = capsys.readouterr()
+            assert "Warning: docker not found, using podman" in captured.err
+
+    def test_explicit_docker_neither_exists(self):
+        with patch("mdify.cli.shutil.which", return_value=None):
+            result = detect_runtime("docker", explicit=True)
+            assert result is None
+
+    def test_explicit_podman_exists(self):
+        with patch("mdify.cli.shutil.which") as mock_which:
+            mock_which.side_effect = (
+                lambda x: "/usr/bin/podman" if x == "podman" else None
+            )
+            result = detect_runtime("podman", explicit=True)
+            assert result == "/usr/bin/podman"
+
+    def test_explicit_podman_fallback_to_docker(self, capsys):
+        with patch("mdify.cli.shutil.which") as mock_which:
+            mock_which.side_effect = (
+                lambda x: "/usr/bin/docker" if x == "docker" else None
+            )
+            result = detect_runtime("podman", explicit=True)
+            assert result == "/usr/bin/docker"
+            captured = capsys.readouterr()
+            assert "Warning: podman not found, using docker" in captured.err
+
+    def test_explicit_podman_neither_exists(self):
+        with patch("mdify.cli.shutil.which", return_value=None):
+            result = detect_runtime("podman", explicit=True)
+            assert result is None