hammerdown 3.1.4__tar.gz → 3.2.2__tar.gz

{hammerdown-3.1.4 → hammerdown-3.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hammerdown
-Version: 3.1.4
+Version: 3.2.2
 Summary: Convert documents to Markdown with extracted images
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -192,37 +192,20 @@ hammerdown -m merged.md report.pdf notes.docx
 Unknown desktop environments cannot be wired up automatically: every file manager exposes its own extension mechanism, and writing entries blindly could break existing associations with no reliable way to detect or undo it. If you need a context-menu action on a system that is not listed above, add a small adapter as described in [CONTRIBUTING.md](CONTRIBUTING.md#adding-support-for-another-platform) and open a pull request.
 
 
-To update `hammerdown` to the latest version:
+To update `hammerdown` to the latest version, use the built-in updater (which also refreshes launcher scripts and context menu entries):
 
 ```sh
-hammerdown --update
+hammerdown --upgrade
 ```
 
-> [!warning]
-> **Legacy version ambiguity (versions below 2.0.0):** due to a release synchronization conflict on version 1.5.2, run the clean recovery sequence below to avoid environment inconsistencies:
->
-> ```sh
-> pip uninstall hammerdown -y
-> pip install --no-cache-dir hammerdown
-> hammerdown --install
-> ```
->
-> Starting from version 1.5.2, `hammerdown --update` automatically refreshes all launcher scripts and file manager integrations without manual reinstallation.
+> [!note]
+> **Upgrading from versions prior to 3.2.1:** due to a packaging configuration issue in versions 3.1.0 through 3.1.4 on PyPI, use `pip install --upgrade hammerdown` to update to 3.2.1+. Starting with version 3.2.1, `hammerdown --upgrade` (or `hammerdown --update`) works automatically.
 
 ### Versioning and release tags
 
-`hammerdown` follows semantic versioning. A tag `vX.Y.Z` (for example `v3.1.0`) is a **stable** release: it is marked as the latest and published to PyPI. A tag with a prerelease suffix (for example `v3.1.0-pre1`) is a **preview**: it is published as a GitHub release but is never marked latest and is not pushed to PyPI.
-
-On every push to `main`, the CI workflow inspects the commit messages since the previous `v*` tag and bumps the version automatically, following Conventional Commits:
-
-- `feat!:` or `fix!:` (breaking change) bumps the **major** version
-- `feat:` bumps the **minor** version
-- `fix:` or `perf:` bumps the **patch** version
-- `docs`/`style`/`refactor`/`test`/`build`/`ci`/`chore` do not trigger a bump
-
-The bump applies **once** to the whole range between two tags (the strongest single change wins), not per commit. The bot commit it creates is excluded from the next run, which keeps the workflow from looping. Preview tags (`-pre`, `-pre1`) are created manually when you want a testable build before the next stable release.
+`hammerdown` follows semantic versioning. A tag `vX.Y.Z` (for example `v3.2.1`) is a **stable** release: it is marked as the latest and published to PyPI. A tag with a prerelease suffix (for example `v3.2.1-pre1`) is a **preview**: it is published as a GitHub release but is never marked latest and is not pushed to PyPI.
 
-Release tags are protected by tag rulesets (`Protect release tags`) on GitHub; the release bot needs `contents: write` permission and must be allowed to create tags for the automatic bump to work.
+Releases are published directly by pushing version tags (`git tag v3.2.1 && git push origin v3.2.1`). The CI release workflow builds standalone binaries for Windows, Linux, and macOS, extracts release notes from `CHANGELOG.md`, and publishes the package to PyPI.
 
 ### Logging and Progress Tracking
 

{hammerdown-3.1.4 → hammerdown-3.2.2}/README.md

@@ -175,37 +175,20 @@ hammerdown -m merged.md report.pdf notes.docx
 Unknown desktop environments cannot be wired up automatically: every file manager exposes its own extension mechanism, and writing entries blindly could break existing associations with no reliable way to detect or undo it. If you need a context-menu action on a system that is not listed above, add a small adapter as described in [CONTRIBUTING.md](CONTRIBUTING.md#adding-support-for-another-platform) and open a pull request.
 
 
-To update `hammerdown` to the latest version:
+To update `hammerdown` to the latest version, use the built-in updater (which also refreshes launcher scripts and context menu entries):
 
 ```sh
-hammerdown --update
+hammerdown --upgrade
 ```
 
-> [!warning]
-> **Legacy version ambiguity (versions below 2.0.0):** due to a release synchronization conflict on version 1.5.2, run the clean recovery sequence below to avoid environment inconsistencies:
->
-> ```sh
-> pip uninstall hammerdown -y
-> pip install --no-cache-dir hammerdown
-> hammerdown --install
-> ```
->
-> Starting from version 1.5.2, `hammerdown --update` automatically refreshes all launcher scripts and file manager integrations without manual reinstallation.
+> [!note]
+> **Upgrading from versions prior to 3.2.1:** due to a packaging configuration issue in versions 3.1.0 through 3.1.4 on PyPI, use `pip install --upgrade hammerdown` to update to 3.2.1+. Starting with version 3.2.1, `hammerdown --upgrade` (or `hammerdown --update`) works automatically.
 
 ### Versioning and release tags
 
-`hammerdown` follows semantic versioning. A tag `vX.Y.Z` (for example `v3.1.0`) is a **stable** release: it is marked as the latest and published to PyPI. A tag with a prerelease suffix (for example `v3.1.0-pre1`) is a **preview**: it is published as a GitHub release but is never marked latest and is not pushed to PyPI.
-
-On every push to `main`, the CI workflow inspects the commit messages since the previous `v*` tag and bumps the version automatically, following Conventional Commits:
-
-- `feat!:` or `fix!:` (breaking change) bumps the **major** version
-- `feat:` bumps the **minor** version
-- `fix:` or `perf:` bumps the **patch** version
-- `docs`/`style`/`refactor`/`test`/`build`/`ci`/`chore` do not trigger a bump
-
-The bump applies **once** to the whole range between two tags (the strongest single change wins), not per commit. The bot commit it creates is excluded from the next run, which keeps the workflow from looping. Preview tags (`-pre`, `-pre1`) are created manually when you want a testable build before the next stable release.
+`hammerdown` follows semantic versioning. A tag `vX.Y.Z` (for example `v3.2.1`) is a **stable** release: it is marked as the latest and published to PyPI. A tag with a prerelease suffix (for example `v3.2.1-pre1`) is a **preview**: it is published as a GitHub release but is never marked latest and is not pushed to PyPI.
 
-Release tags are protected by tag rulesets (`Protect release tags`) on GitHub; the release bot needs `contents: write` permission and must be allowed to create tags for the automatic bump to work.
+Releases are published directly by pushing version tags (`git tag v3.2.1 && git push origin v3.2.1`). The CI release workflow builds standalone binaries for Windows, Linux, and macOS, extracts release notes from `CHANGELOG.md`, and publishes the package to PyPI.
 
 ### Logging and Progress Tracking
 

{hammerdown-3.1.4 → hammerdown-3.2.2}/pyproject.toml

@@ -26,16 +26,11 @@ hammerdown = "hammerdown.cli:main"
 
 [tool.setuptools]
 package-dir = {"" = "src"}
-packages = [
-    "hammerdown",
-    "hammerdown.parsers",
-    "hammerdown.parsers.math",
-    "hammerdown.integrations",
-    "hammerdown.parsers.office",
-]
+[tool.setuptools.packages.find]
+where = ["src"]
 
 [tool.setuptools.package-data]
-hammerdown = ["assets/icon.ico", "assets/icon.png", "parsers/math/symbols.json"]
+hammerdown = ["assets/*", "parsers/math/symbols.json"]
 
 [tool.setuptools.dynamic]
 version = {attr = "hammerdown.__version__"}

{hammerdown-3.1.4 → hammerdown-3.2.2}/src/hammerdown/__init__.py

@@ -36,7 +36,7 @@ from .core import (
 )
 from .batch import convert_files
 
-__version__ = "3.1.4"
+__version__ = "3.2.2"
 
 __all__ = [
     "APP_NAME",

hammerdown-3.2.2/src/hammerdown/batch/__init__.py

@@ -0,0 +1,508 @@
+from __future__ import annotations
+
+import argparse
+import logging
+import os
+import re
+import sys
+import tempfile
+import urllib.error
+from pathlib import Path
+from typing import Sequence
+
+from ..core import (
+    TEXT_EXTENSIONS,
+    convert_file,
+    get_conversion_estimate_seconds,
+)
+from ..core.discovery import expand_paths, output_paths as compute_output_paths
+from ..core.google_drive import download_google_url, extract_file_id, is_google_drive_url
+from ..core.ipc import IPCCoordinator, try_delegate_to_coordinator
+from ..core.merge import (
+    append_merged_document,
+    initialize_merge_file,
+    merge_asset_paths,
+    merge_root_for_inputs,
+    render_merged_markdown,
+)
+from ..ui.batch_ui import BatchUI
+from ..core.stdout_mode import confirm_stdout, run_stdout_conversion
+from ..core.formatting import format_duration
+from ..core.path_utils import normalize_path
+from ..core.platform_utils import is_windows
+
+logger = logging.getLogger("hammerdown")
+
+
+def _ensure_console_window() -> None:
+    """Show the current console or allocate a fallback console on Windows."""
+    if os.name != "nt":
+        return
+
+    import ctypes
+
+    kernel32 = ctypes.windll.kernel32
+    user32 = ctypes.windll.user32
+    hwnd = kernel32.GetConsoleWindow()
+    if not hwnd:
+        if not kernel32.AllocConsole():
+            return
+        sys.stdout = open("CONOUT$", "w", encoding="utf-8", buffering=1)
+        sys.stderr = open("CONOUT$", "w", encoding="utf-8", buffering=1)
+        sys.stdin = open("CONIN$", "r", encoding="utf-8")
+        for name in ("", "hammerdown"):
+            for handler in logging.getLogger(name).handlers:
+                if isinstance(handler, logging.StreamHandler) and getattr(handler, "stream", None) is None:
+                    handler.setStream(sys.stderr)
+        hwnd = kernel32.GetConsoleWindow()
+    kernel32.SetConsoleTitleW("Hammerdown")
+    if hwnd:
+        user32.ShowWindow(hwnd, 5)
+        user32.SetForegroundWindow(hwnd)
+
+
+def hand_off_to_windows_terminal(
+    files: Sequence[str],
+    args: argparse.Namespace,
+    merge_auto: bool,
+) -> bool:
+    """Run an Explorer selection in one Windows Terminal window.
+
+    Returns ``False`` when this is not a Windows context-menu run or when
+    Windows Terminal is unavailable, so the caller can fall back to a console.
+    """
+    if not is_windows() or getattr(args, "context_worker", False):
+        return False
+    if not getattr(args, "coordinator", False):
+        return False
+
+    from ..integrations.windows_terminal import launch_context_worker
+
+    return launch_context_worker(
+        files,
+        merge_auto=merge_auto,
+        include=getattr(args, "include", []),
+        exclude=getattr(args, "exclude", []),
+        overwrite=getattr(args, "overwrite", False),
+        skip_existing=getattr(args, "skip_existing", False),
+        output_dir=getattr(args, "output_dir", None),
+    )
+
+
+def run_batch(args: argparse.Namespace) -> int:
+    raw_files = args.files
+    merge_requested = getattr(args, "merge", None)
+    merge_auto = getattr(args, "merge_auto", False)
+    if merge_requested and getattr(args, "overwrite", False):
+        logger.error("--merge cannot be combined with --overwrite")
+        return 1
+    if merge_requested and getattr(args, "output_dir", None):
+        logger.error("--merge cannot be combined with --output-dir")
+        return 1
+    if not raw_files:
+        logger.info("No supported documents found to convert")
+        return 0
+
+    # Resolve Google Docs/Drive file URLs by downloading them first.
+    google_downloaded: set[str] = set()
+    google_failed: list[tuple[str, str]] = []
+    resolved_files: list[str] = []
+    google_staging = tempfile.TemporaryDirectory(prefix="hammerdown-remote-")
+    try:
+        google_staging_dir = Path(google_staging.name)
+        for raw in raw_files:
+            if is_google_drive_url(raw):
+                try:
+                    cached = download_google_url(raw, google_staging_dir)
+                    if cached is None:
+                        google_failed.append((raw, "unsupported Google Drive link"))
+                        continue
+                    google_downloaded.add(str(cached.resolve()))
+                    resolved_files.append(str(cached))
+                    logger.info("Downloaded %s to %s", raw, cached.name)
+                except urllib.error.HTTPError as e:
+                    reason = f"access denied (HTTP {e.code})" if e.code in (401, 403) else f"not found (HTTP {e.code})"
+                    google_failed.append((raw, reason))
+                    logger.error("Could not download Google Drive URL: %s (%s)", raw, reason)
+                except (urllib.error.URLError, OSError) as e:
+                    google_failed.append((raw, f"network error: {e}"))
+                    logger.error("Could not download Google Drive URL: %s (network error)", raw)
+            else:
+                resolved_files.append(raw)
+        raw_files = resolved_files
+
+        output_dir = getattr(args, "output_dir", None)
+        output_root = Path(output_dir).resolve() if output_dir else None
+        if output_root is not None and output_root.exists() and not output_root.is_dir():
+            logger.error("output directory path is not a directory: %s", output_root)
+            return 1
+    finally:
+        google_staging.cleanup()
+
+    include_patterns = [re.compile(pattern) for pattern in getattr(args, "include", [])]
+    exclude_patterns = [re.compile(pattern) for pattern in getattr(args, "exclude", [])]
+    targets = expand_paths(
+        raw_files,
+        excluded_dir=output_root,
+        include_patterns=include_patterns,
+        exclude_patterns=exclude_patterns,
+    )
+    # Surface Google links that could not be downloaded as explicit errors
+    for url, reason in google_failed:
+        # Give a readable label instead of just Path(url).name (which is often "edit")
+        label = url
+        file_id = extract_file_id(url)
+        if file_id:
+            label = f"Google Doc ({file_id[:8]}...)"
+        targets.append((label, reason))
+    if not targets:
+        logger.info("No supported documents found to convert")
+        return 0
+
+    targets.sort(key=lambda item: item[0].lower())
+    files = [path for path, error in targets if error is None]
+    ui_files = [path for path, _ in targets]
+    estimates = [
+        get_conversion_estimate_seconds(Path(path)) if error is None else None
+        for path, error in targets
+    ]
+
+    if getattr(args, "stdout", False):
+        initial_errors = [(path, error) for path, error in targets if error is not None]
+        for path, error in initial_errors:
+            print(f"[!] {Path(path).name}: {error}", file=sys.stderr)
+        file_estimates = [estimate for (_, error), estimate in zip(targets, estimates) if error is None]
+        if getattr(args, "confirm", False) and files and not confirm_stdout(files, file_estimates):
+            return 1
+        if not files:
+            return 1 if initial_errors else 0
+        conversion_status = run_stdout_conversion(files, raw_files)
+        return 1 if initial_errors or conversion_status else 0
+
+    context_worker = getattr(args, "context_worker", False)
+    use_ipc = (
+        (getattr(args, "coordinator", False) or os.environ.get("HAMMERDOWN_COORDINATOR") == "1")
+        and not context_worker
+    )
+    options = {
+        "overwrite": getattr(args, "overwrite", False),
+        "skip_existing": getattr(args, "skip_existing", False),
+    }
+
+    coordinator = IPCCoordinator() if use_ipc else None
+    coordinator_started = coordinator.start() if coordinator else False
+    if use_ipc and not coordinator_started:
+        if files and not any(error for _, error in targets) and try_delegate_to_coordinator(files, options):
+            logger.info("Delegated %d files to active hammerdown coordinator", len(files))
+        return 0
+
+    if coordinator is not None and coordinator_started:
+        initial_errors = [target for target in targets if target[1] is not None]
+        collected_files = coordinator.collect_files(files, assembly_timeout=2.0)
+        targets = expand_paths(
+            [*raw_files, *collected_files],
+            excluded_dir=output_root,
+            include_patterns=include_patterns,
+            exclude_patterns=exclude_patterns,
+        )
+        targets.extend(
+            target for target in initial_errors if target not in targets
+        )
+        targets.sort(key=lambda item: item[0].lower())
+        files = [path for path, error in targets if error is None]
+        ui_files = [path for path, _ in targets]
+        estimates = [
+            get_conversion_estimate_seconds(Path(path)) if error is None else None
+            for path, error in targets
+        ]
+        output_path_inputs = [*raw_files, *collected_files]
+
+        if hand_off_to_windows_terminal(list(dict.fromkeys(output_path_inputs)), args, merge_auto):
+            coordinator.stop()
+            return 0
+        _ensure_console_window()
+    elif use_ipc:
+        return 0
+    else:
+        output_path_inputs = raw_files
+
+    # Resolve default merge output for --right-click --merge-auto once the full
+    # selection is known, so the target does not depend on which process won
+    # the coordinator race.
+    if merge_auto and merge_requested is None and files:
+        merge_requested = str(Path(files[0]).parent / "hammerdowned.md")
+
+    merge_target = Path(normalize_path(merge_requested)) if merge_requested else None
+    merge_sources = [path for path, error in targets if error is None]
+    if merge_target is not None and any(Path(path).resolve() == merge_target.resolve() for path in merge_sources):
+        logger.error("merge target cannot be one of the source files: %s", merge_target)
+        if coordinator:
+            coordinator.stop()
+        return 1
+
+    merge_root = (
+        merge_root_for_inputs(output_path_inputs, [Path(path) for path in merge_sources])
+        if merge_target is not None
+        else None
+    )
+    merge_skipped = bool(merge_target is not None and args.skip_existing and merge_target.exists())
+
+    try:
+        if merge_target is not None:
+            target_paths = [merge_target] * len(targets)
+        elif output_root is not None:
+            target_paths = compute_output_paths(output_path_inputs, targets, output_root)
+        else:
+            target_paths = []
+            for path, _ in targets:
+                p = Path(path)
+                # Google-downloaded HTML lives in a temporary staging folder; write
+                # its Markdown output next to the user (cwd) or in -o/--output-dir.
+                if str(p.resolve()) in google_downloaded:
+                    base = output_root if output_root is not None else Path.cwd()
+                    target_paths.append(
+                        base / f"hm_{p.stem}_{p.suffix.lower().lstrip('.')}.md"
+                    )
+                else:
+                    target_paths.append(
+                        p.parent / f"hm_{p.stem}_{p.suffix.lower().lstrip('.')}.md"
+                    )
+    except ValueError as exc:
+        logger.error("%s", exc)
+        if coordinator:
+            coordinator.stop()
+        return 1
+
+    results: list[bool] = []
+    merged_count = 0
+    merge_initialized = False
+    batch_ui = BatchUI(ui_files, estimates=estimates)
+
+    if batch_ui.can_redraw:
+        batch_ui.start()
+
+    conversion_finished = False
+    try:
+        for idx, (f, error) in enumerate(targets):
+            f_path = Path(f)
+            if error:
+                batch_ui.fail_file(idx, error)
+                results.append(False)
+                continue
+
+            estimate = estimates[idx]
+            hint = f"~{format_duration(estimate)}" if estimate is not None else ""
+            batch_ui.start_file(idx, hint=hint)
+            extension = f_path.suffix.lower()
+            output_path = target_paths[idx]
+            status_info = ""
+            if merge_target is not None:
+                if merge_skipped:
+                    status_info = f"skipped, existing merge output: {merge_target.name}"
+            elif args.skip_existing and output_path.exists() and output_path != f_path:
+                status_info = f"skipped, existing output: {output_path.name}"
+            elif args.overwrite and extension in TEXT_EXTENSIONS:
+                status_info = "overwritten"
+            elif args.overwrite:
+                status_info = "overwrite ignored (binary file)"
+
+            if merge_skipped:
+                batch_ui.complete_file(idx, True, 0.0, info=status_info)
+                results.append(True)
+                continue
+
+            # Directly skip if the output exists to avoid re-parsing
+            if args.skip_existing and output_path.exists() and output_path != f_path and merge_target is None:
+                batch_ui.complete_file(idx, True, 0.0, info=status_info)
+                results.append(True)
+                continue
+
+            def on_progress(current: int, total: int, unit: str = "pages") -> None:
+                batch_ui.update_progress(idx, current, total, unit)
+
+            def on_complete(success: bool, dur: float, imgs: int, tokens: int) -> None:
+                batch_ui.complete_file(idx, success, dur, imgs, tokens, status_info)
+
+            error_count_before = len(batch_ui.errors)
+            logger_was_disabled = logger.disabled
+            logger.disabled = True
+            is_google_cache = str(f_path.resolve()) in google_downloaded
+            try:
+                res = convert_file(
+                    f_path,
+                    overwrite=args.overwrite and not is_google_cache,
+                    skip_existing=args.skip_existing if merge_target is None else False,
+                    progress_callback=on_progress,
+                    completion_callback=on_complete,
+                    batch_mode=True,
+                    target_dir=(
+                        output_path.parent
+                        if merge_target is None and (output_root is not None or is_google_cache)
+                        else None
+                    ),
+                    asset_dir=(
+                        merge_asset_paths(f_path, merge_root, merge_target)[0]
+                        if merge_target is not None and merge_root is not None
+                        else None
+                    ),
+                    write_markdown=merge_target is None,
+                )
+            finally:
+                logger.disabled = logger_was_disabled
+            succeeded = bool(res)
+            if not succeeded:
+                reason = getattr(res, "error", None) or "conversion failed"
+                if len(batch_ui.errors) > error_count_before:
+                    name, previous_reason = batch_ui.errors[-1]
+                    batch_ui.errors[-1] = (name, reason or previous_reason)
+                else:
+                    batch_ui.errors.append((f_path.name, reason))
+
+                if merge_target is not None and merge_root is not None:
+                    try:
+                        if not merge_initialized:
+                            initialize_merge_file(merge_target, merge_sources, merge_root)
+                            merge_initialized = True
+                        _, asset_prefix = merge_asset_paths(f_path, merge_root, merge_target)
+                        append_merged_document(
+                            merge_target,
+                            f_path,
+                            "",
+                            merge_root,
+                            asset_prefix,
+                            error=reason,
+                        )
+                    except OSError:
+                        pass
+            if succeeded and merge_target is not None and merge_root is not None:
+                if res.markdown is None:
+                    succeeded = False
+                    batch_ui.converted_count -= 1
+                    batch_ui.statuses[idx] = "[!]"
+                    batch_ui.details[idx] = "-"
+                    batch_ui.errors.append((f_path.name, "conversion returned no Markdown for merge"))
+                else:
+                    try:
+                        if not merge_initialized:
+                            initialize_merge_file(merge_target, merge_sources, merge_root)
+                            merge_initialized = True
+                        _, asset_prefix = merge_asset_paths(f_path, merge_root, merge_target)
+                        append_merged_document(
+                            merge_target,
+                            f_path,
+                            res.markdown,
+                            merge_root,
+                            asset_prefix,
+                        )
+                        merged_count += 1
+                    except OSError as exc:
+                        succeeded = False
+                        batch_ui.converted_count -= 1
+                        batch_ui.statuses[idx] = "[!]"
+                        batch_ui.details[idx] = "-"
+                        batch_ui.errors.append((f_path.name, f"could not append to merge output: {exc}"))
+            results.append(succeeded)
+        conversion_finished = True
+    finally:
+        if not conversion_finished:
+            batch_ui.stop()
+        if coordinator:
+            coordinator.stop()
+
+    failed_count = sum(not result for result in results)
+    merge_failed = False
+    if merge_target is not None and any(results) and not merge_skipped:
+        if merge_initialized and merged_count > 0 and merge_target.is_file():
+            batch_ui.add_result("Merged documents", merged_count)
+        else:
+            merge_failed = True
+            batch_ui.errors.append((merge_target.name, "merge did not produce an output file"))
+
+    batch_ui.finish()
+    batch_ui.add_result("Converted files", batch_ui.converted_count)
+    batch_ui.add_result("Extracted images", batch_ui.image_count)
+    batch_ui.add_result("Skipped existing outputs", batch_ui.skipped_count)
+    batch_ui.add_result("Overwritten text sources", batch_ui.overwritten_count)
+
+    if not batch_ui.can_redraw:
+        batch_ui.print_summary()
+    if batch_ui.errors:
+        batch_ui.print_error_list()
+    batch_ui.print_results()
+
+    if (
+        getattr(args, "right_click", False)
+        or getattr(args, "coordinator", False)
+        or os.environ.get("HAMMERDOWN_COORDINATOR") == "1"
+    ):
+        from rich.console import Console
+        from rich.text import Text
+
+        try:
+            follow_up = Text("\nPress ")
+            follow_up.append("Enter", style="orange1")
+            follow_up.append(" to exit... ")
+            Console().print(follow_up, end="")
+            input()
+        except (EOFError, KeyboardInterrupt):
+            pass
+
+    return 1 if failed_count or merge_failed else 0
+
+
+def convert_files(
+    files: Sequence[str | os.PathLike[str]],
+    *,
+    include: Sequence[str] = (),
+    exclude: Sequence[str] = (),
+    overwrite: bool = False,
+    skip_existing: bool = False,
+    output_dir: str | os.PathLike[str] | None = None,
+    merge: str | os.PathLike[str] | None = None,
+    stdout: bool = False,
+    confirm: bool = False,
+) -> int:
+    """Convert selected files using the same public options as the CLI."""
+    if confirm and not stdout:
+        raise ValueError("confirm can only be used with stdout")
+    if stdout and (merge is not None or output_dir is not None or overwrite or skip_existing):
+        raise ValueError("stdout cannot be combined with merge, output_dir, overwrite, or skip_existing")
+    if merge is not None and overwrite:
+        raise ValueError("merge cannot be combined with overwrite")
+    if merge is not None and output_dir is not None:
+        raise ValueError("merge cannot be combined with output_dir")
+    if overwrite and skip_existing:
+        raise ValueError("overwrite cannot be combined with skip_existing")
+    if overwrite and output_dir is not None:
+        raise ValueError("overwrite cannot be combined with output_dir")
+    include_patterns = _normalize_patterns(include, "include")
+    exclude_patterns = _normalize_patterns(exclude, "exclude")
+    namespace = argparse.Namespace(
+        files=[os.fspath(path) for path in files],
+        include=include_patterns,
+        exclude=exclude_patterns,
+        overwrite=overwrite,
+        skip_existing=skip_existing,
+        output_dir=os.fspath(output_dir) if output_dir is not None else None,
+        merge=os.fspath(merge) if merge is not None else None,
+        stdout=stdout,
+        confirm=confirm,
+        coordinator=False,
+        context_worker=False,
+        right_click=False,
+    )
+    return run_batch(namespace)
+
+
+def _normalize_patterns(patterns: Sequence[str], flag: str) -> list[str]:
+    normalized_patterns: list[str] = []
+    for pattern in patterns:
+        normalized = pattern.strip()
+        if len(normalized) >= 2 and normalized[0] == normalized[-1] and normalized[0] in {"'", '"'}:
+            normalized = normalized[1:-1]
+        try:
+            re.compile(normalized)
+        except re.error as exc:
+            raise ValueError(f"{flag} invalid regular expression {pattern!r}: {exc}") from exc
+        normalized_patterns.append(normalized)
+    return normalized_patterns

{hammerdown-3.1.4 → hammerdown-3.2.2}/src/hammerdown/cli.py

@@ -89,7 +89,13 @@ def _main(argv: Sequence[str] | None = None) -> int:
     action = parser.add_mutually_exclusive_group()
     action.add_argument("--install", action="store_true", help="Install the file-manager integration")
     action.add_argument("--uninstall", action="store_true", help="Remove the file-manager integration")
-    parser.add_argument("--update", action="store_true", help="Update hammerdown to the latest version")
+    parser.add_argument(
+        "--update",
+        "--upgrade",
+        dest="update",
+        action="store_true",
+        help="Update hammerdown to the latest version",
+    )
     parser.add_argument(
         "-i",
         "--include",