any2md 1.1.0__tar.gz → 1.2.0__tar.gz

{any2md-1.1.0 → any2md-1.2.0}/.gitignore

@@ -43,4 +43,3 @@ logo/
 # ZERG / dev tooling
 .gsd/
 .zerg/
-.devcontainer/

{any2md-1.1.0 → any2md-1.2.0}/CHANGELOG.md

@@ -4,6 +4,146 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
+## [1.2.0] — 2026-11-09
+
+Drops Python 3.10 to take the Pillow 13 security fixes, and fixes
+missing H1 headings in HTML/URL output.
+
+### Removed
+
+- **Python 3.10 support.** `requires-python` is now `>=3.11`. Pillow
+  13.0.0 is the only release that fixes the advisories below, and it
+  requires Python 3.11. Python 3.10 reached end-of-life in October 2026.
+  pip on 3.10 keeps resolving any2md 1.1.1, which pins the vulnerable
+  pillow 12.x; upgrade the interpreter to get these fixes. The `tomli`
+  fallback dependency is gone with it (stdlib `tomllib` covers 3.11+),
+  and the CI matrix now tests 3.11, 3.12, and 3.13.
+
+### Security
+
+- **Pillow 13.0.0.** The `pillow>=12.2.0,<13` range held installs on a
+  release with 39 published advisories (e.g. CVE-2026-112395), all fixed
+  in 13.0.0. The range is now `pillow>=13.0.0,<14`. Docling's packages
+  accept `pillow<14`, so the `high-fidelity` extra still resolves.
+- **Locked dev-container dependencies.** `.devcontainer/requirements.lock`
+  and `requirements.txt` move certifi, lxml-html-clean, soupsieve, and
+  urllib3 to their fixed releases (lxml follows to 6.1.3). Both
+  lockfiles now audit clean with `pip-audit`.
+
+### Fixed
+
+- **HTML/URL bodies had no H1.** trafilatura keeps a heading only
+  when it sits inside the content node it selects. A page `<h1>` in a
+  hero banner or `<header>` block outside that node was dropped, so
+  nearly every blog page warned `validator: H1 count is 0 (expected 1)`
+  (106 of 106 labs.zenity.io posts, 182 of 214 zenity.io/blog posts).
+  The HTML converter now restores the H1 before the pipeline runs:
+  - The body already has an H1: unchanged.
+  - The first body line repeats the title as plain or bold text: that
+    line is promoted to the H1, so the title appears once.
+  - Otherwise `# <title>` is inserted as the first line.
+  - No title is available: unchanged (the validator still warns).
+
+  The H1 text is the page's own `<h1>` when the page has exactly one
+  non-empty `<h1>`, else trafilatura's metadata title. `content_hash`,
+  `token_estimate`, `word_count`, `recommended_chunk_level`, and
+  `abstract_for_rag` are computed from the body with the H1 in place.
+  PDF, DOCX, and TXT output is unchanged.
+- **HTML/URL heading levels skipped below the H1.** Many CMS templates
+  mark body sections as H3 or H4 directly under the page H1, so the
+  restored H1 surfaced `validator: heading level skip h1 -> h3` (34 of
+  the 320 zenity posts above). Headings are now re-ranked by section
+  depth below the H1: siblings stay siblings, nesting is kept, and only
+  the `#` prefix changes (`H3, H3, H4, H3` becomes `H2, H2, H3, H2`).
+  Bodies without skips are byte-identical. All 320 posts now convert
+  with 0 validator warnings.
+
+### Added
+
+- **`seo_title`** frontmatter extension field (HTML/URL only). Holds
+  trafilatura's metadata title (`og:title` / `<title>`) when it differs
+  from `title`. Omitted when the two match.
+
+### Changed
+
+- **CI pins ruff to 0.15.22.** Ruff 0.16 and later enable a wider default
+  rule set this repo has not adopted, which failed the required lint check
+  on an unchanged `main`. The `dev` extra pins the same version.
+- **Release workflow pins `pypa/gh-action-pypi-publish` v1.14.3.** The
+  previous pin bundled twine 6.1, which rejects the Metadata-Version 2.5
+  that current hatchling writes, so uploads failed before reaching the
+  index. The validate step now pins `build==1.6.1` and `twine==7.0.0`.
+- **HTML/URL `title` follows the visible page heading.** `title` is
+  still derived from the body H1, and the body H1 is now the page's
+  `<h1>`. On pages whose `og:title` differs from their `<h1>`, `title`
+  changes from the SEO title to the visible heading. The previous value
+  moves to `seo_title`. Pin a title with `--meta title=...` if you
+  depend on the old value.
+
+## [1.1.1] — 2026-05-07
+
+Security patch release. Closes 10 findings from a comprehensive scan
+(bandit, snyk-code, gitleaks, pip-audit, trivy, manual review) plus
+a 5-round adversarial review of the implementation plan.
+
+### Security
+
+- **SSRF intra-hop DNS-rebind**: `safe_fetch` now resolves the
+  hostname once, validates the IP against an allowlist, and passes
+  the validated IP through to `socket.create_connection` via a
+  custom `HTTPSConnection`. Defeats attacks that return a public IP
+  to a validator and a private IP (e.g., `169.254.169.254`) to the
+  connector. `ProxyHandler({})` explicitly suppresses
+  `HTTP_PROXY`/`HTTPS_PROXY` env vars that would otherwise route
+  traffic past the validator.
+- **IP allowlist**: switched from a four-flag denylist
+  (`is_private | is_reserved | is_loopback | is_link_local`) to an
+  allowlist (`is_global and not is_multicast and not is_unspecified`).
+  **Breaking** for users on multicast / CGNAT / IETF-reserved
+  networks fetching same-network resources; pre-fetch with `curl`
+  and pass `--from-file` as a workaround.
+- **Frontmatter override-key validation**: keys must now match
+  `^[A-Za-z_][A-Za-z0-9_-]*$`. Defends against newline-injection in
+  TOML basic-string keys that produced split YAML lines.
+  **Breaking** for TOML configs with quoted keys containing
+  whitespace or punctuation.
+- **URL credentials and sensitive query parameters** in `userinfo`
+  and matching `(?i)(token|api[_-]?key|access[_-]?token|bearer|signature|sig|password|secret|aws[_-]?session[_-]?token)$`
+  are scrubbed before any logging, persistence, or filename
+  derivation. IPv6 host brackets preserved across the scrub.
+- **Docling image saves** use `O_EXCL|O_NOFOLLOW` to refuse symlink
+  TOCTOU.
+- **`atomic_write_text`** tightens the symlink-check window via
+  `os.lstat` immediately before `os.replace`. Parent-dir hardening
+  deferred to v1.2 per the operator-trusted threat model.
+- **Stderr/stdout sanitizer** extended with Unicode bidi
+  (U+202A–E, U+2066–9), zero-width chars (U+200B–F, U+FEFF), and
+  the BOM. New `any2md._logging` module; `_sanitize_log_text`
+  re-exported from `any2md.converters.docx` for one release.
+- **`publish.yml` workflow**: top-level `permissions: contents: read`;
+  both publish jobs flip to `attestations: true` for PEP 740 sigstore
+  provenance.
+
+### Fixed
+
+- `wikipedia.org` heuristic host check no longer matches
+  `evilwikipedia.org`. Pure correctness fix; impact was incorrect
+  text formatting only, not a security boundary.
+- `_USER_AGENT` no longer hardcoded to `any2md/1.0.6`; derives from
+  `__version__`.
+
+### Changed
+
+- `requirements.txt` is now a generated artifact; canonical source
+  is `.devcontainer/requirements.lock` with hashes
+  (`--require-hashes` enforced in `.devcontainer/devcontainer.json`).
+  See `CONTRIBUTING.md` for the dep-update workflow.
+- `load_toml()` now warns to stderr on parse error rather than
+  silently returning `{}`.
+- `.devcontainer/` is now tracked in git (was previously ignored)
+  so the security-critical Codespace bootstrap config is
+  version-controlled.
+
 ## [1.1.0] — 2026-05-04
 
 Performance and library-mode hygiene release.

{any2md-1.1.0 → any2md-1.2.0}/CONTRIBUTING.md

@@ -29,7 +29,7 @@ the test suite gates Docling-dependent tests with
 `@pytest.mark.skipif(not has_docling(), …)` so they're transparently skipped
 without it. Coverage of fallback paths is unaffected.
 
-Python 3.10 or later is required.
+Python 3.11 or later is required.
 
 ## Running tests
 
@@ -131,6 +131,24 @@ The flow:
 Don't tag and release directly without the PR — CI gates exist for a
 reason.
 
+## Updating dependencies
+
+Dependencies are declared in `pyproject.toml` and locked into both:
+
+- `.devcontainer/requirements.lock` — hash-locked, used by Codespace `postCreateCommand` (`pip install --require-hashes`).
+- `requirements.txt` — non-hash form, kept for backwards compatibility with `pip install -r requirements.txt` consumers.
+
+To add or update a dep:
+
+1. Edit `pyproject.toml` `[project] dependencies` (or the relevant `[project.optional-dependencies]` group).
+2. Regenerate both lockfiles in a venv with `pip-tools` installed:
+
+       pip-compile pyproject.toml --generate-hashes --resolver=backtracking \
+         -o .devcontainer/requirements.lock
+       pip-compile pyproject.toml --resolver=backtracking -o requirements.txt
+
+3. Commit all three files together.
+
 ## Pull request process
 
 - Branch off `main` (or off a phase branch like `v1.0` if one is open for

{any2md-1.1.0 → any2md-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: any2md
-Version: 1.1.0
+Version: 1.2.0
 Summary: Convert PDF, DOCX, HTML, and TXT files — or web pages by URL — to clean, LLM-optimized Markdown with YAML frontmatter.
 Project-URL: Homepage, https://github.com/rocklambros/any2md
 Project-URL: Issues, https://github.com/rocklambros/any2md/issues
@@ -11,13 +11,13 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Text Processing :: Markup :: Markdown
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Requires-Dist: beautifulsoup4<5,>=4.12.0
 Requires-Dist: defusedxml<1,>=0.7.1
 Requires-Dist: lxml<7,>=6.1.0
 Requires-Dist: mammoth<2,>=1.6.0
 Requires-Dist: markdownify<2,>=0.13.0
-Requires-Dist: pillow<13,>=12.2.0
+Requires-Dist: pillow<14,>=13.0.0
 Requires-Dist: pymupdf4llm<1,>=0.0.17
 Requires-Dist: pymupdf<2,>=1.24.0
 Requires-Dist: trafilatura<3,>=1.12.0
@@ -27,7 +27,7 @@ Requires-Dist: pytest-snapshot>=0.9.0; extra == 'dev'
 Requires-Dist: pytest>=8.0.0; extra == 'dev'
 Requires-Dist: pyyaml>=6.0; extra == 'dev'
 Requires-Dist: reportlab>=4.0.0; extra == 'dev'
-Requires-Dist: ruff>=0.6.0; extra == 'dev'
+Requires-Dist: ruff==0.15.22; extra == 'dev'
 Provides-Extra: high-fidelity
 Requires-Dist: docling>=2.0.0; extra == 'high-fidelity'
 Description-Content-Type: text/markdown

{any2md-1.1.0 → any2md-1.2.0}/SECURITY.md

@@ -81,3 +81,25 @@ If you operate any2md in a hardened environment:
 
 No publicly disclosed vulnerabilities to date. Future advisories will
 appear at https://github.com/rocklambros/any2md/security/advisories.
+
+## Trust boundaries
+
+`any2md` is an operator-trusted CLI distributed via PyPI for desktop and CI use.
+
+**Trusted:** the operator, their filesystem, their `--output-dir`, and the Python interpreter they invoke. CLI flags and `--meta key=val` arguments are operator-controlled.
+
+**Untrusted:**
+- URLs passed to `any2md` (may resolve to internal IPs, redirect, or carry credentials in userinfo/query).
+- Documents (PDF/DOCX/HTML) passed for conversion (may embed crafted images, control characters, malicious metadata).
+- `.any2md.toml` config files discovered via cwd-walking (an attacker who can drop a file in any ancestor directory can inject frontmatter overrides).
+- HTTP responses from URLs (may carry hostile redirects, oversized bodies, control characters in headers).
+
+**Out of scope:** multi-tenant service hosting; running `any2md` against attacker-supplied output directories; supply-chain compromise of pinned dependencies; protection against an operator who has chosen `--output-dir` pointing at a shared/symlinked directory.
+
+## Dependency-drift policy
+
+If `pip-audit` reports a NEW HIGH/CRITICAL vulnerability between baseline and release-cut, the policy is:
+
+1. Bump the dep within its compatible range (regenerate `.devcontainer/requirements.lock` and `requirements.txt`) and re-cut the rc.
+2. If no compatible fix exists, document in CHANGELOG `## Known issues` and ship only if the codepath is mitigated by other code (e.g., XXE blocked by `defusedxml`).
+3. If neither is possible, hold the release until upstream lands a fix.

{any2md-1.1.0 → any2md-1.2.0}/any2md/__init__.py

@@ -2,7 +2,7 @@
 
 from any2md._docling_cache import docling_session, release_models
 
-__version__ = "1.1.0"
+__version__ = "1.2.0"
 
 __all__ = [
     "__version__",

{any2md-1.1.0 → any2md-1.2.0}/any2md/_docling.py

@@ -33,5 +33,5 @@ def install_hint() -> None:
     global _hint_emitted
     if _hint_emitted:
         return
-    print(f"  WARN: {INSTALL_HINT_MSG}", file=sys.stderr)
+    print(f"  WARN: {INSTALL_HINT_MSG}", file=sys.stderr)  # log-safe: literal
     _hint_emitted = True

{any2md-1.1.0 → any2md-1.2.0}/any2md/_docling_cache.py

@@ -271,7 +271,9 @@ class ConverterCache:
 
         if is_quiet() or not sys.stderr.isatty():
             return True
-        print("  Loading Docling models (one-time)...", file=sys.stderr)
+        print(
+            "  Loading Docling models (one-time)...", file=sys.stderr
+        )  # log-safe: literal
         return True
 
 

any2md-1.2.0/any2md/_http.py

@@ -0,0 +1,199 @@
+"""SSRF-safe HTTP fetching for any2md.
+
+Defenses against:
+  - non-http(s) schemes
+  - URLs resolving to non-public addresses (private, multicast, CGNAT, etc.)
+  - DNS rebinding via redirect (per-hop revalidation)
+  - DNS rebinding INTRA-hop (IP pinned through to socket.create_connection,
+    so the IP we validated is the IP we connect to)
+  - Environment-proxy bypass (ProxyHandler({}) suppresses HTTP_PROXY/HTTPS_PROXY)
+  - Decompression / huge-response DoS (20 MB body cap)
+  - Redirect loops / excessive hops (max 3)
+"""
+
+from __future__ import annotations
+
+import http.client
+import ipaddress
+import socket
+import urllib.error
+import urllib.parse
+import urllib.request
+
+from any2md import __version__
+
+_MAX_REDIRECT_HOPS = 3
+_FETCH_TIMEOUT = 15  # seconds
+_MAX_RESPONSE_BYTES = 20 * 1024 * 1024  # 20 MB cap on body read
+_USER_AGENT = f"any2md/{__version__}"
+
+
+def _addr_allowed(addr) -> bool:
+    """Allowlist policy: globally routable, non-multicast, non-unspecified."""
+    return bool(addr.is_global) and not addr.is_multicast and not addr.is_unspecified
+
+
+def _resolve_and_validate(hostname: str) -> tuple[list[str], str | None]:
+    """One-shot DNS resolution + IP-class validation.
+
+    Returns ``(ips, None)`` on success or ``([], error)`` on rejection.
+    Deny-on-any: if ANY resolved address fails policy, the whole hostname
+    is rejected (defends against multi-record split-result attacks).
+    """
+    try:
+        infos = socket.getaddrinfo(hostname, None, type=socket.SOCK_STREAM)
+    except socket.gaierror:
+        return [], f"cannot resolve host: {hostname}"
+    ips: list[str] = []
+    for *_, sockaddr in infos:
+        ip_str = sockaddr[0]
+        try:
+            addr = ipaddress.ip_address(ip_str)
+        except ValueError:
+            continue
+        if not _addr_allowed(addr):
+            return [], f"URL resolves to disallowed address: {addr}"
+        ips.append(ip_str)
+    if not ips:
+        return [], f"no usable address for {hostname}"
+    return ips, None
+
+
+def validate_url(url: str) -> str | None:
+    """Validate scheme + hostname + IP class. Returns error or None.
+
+    One-shot DNS resolution; intra-hop rebind defense lives in
+    :func:`safe_fetch` (which pins the connection to the resolved IP).
+    """
+    parsed = urllib.parse.urlsplit(url)
+    if parsed.scheme not in ("http", "https"):
+        return f"unsupported scheme: {parsed.scheme!r}"
+    if not parsed.hostname:
+        return f"no hostname in URL: {url}"
+    _ips, err = _resolve_and_validate(parsed.hostname)
+    return err
+
+
+class _NoFollowRedirect(urllib.request.HTTPRedirectHandler):
+    """Disable urllib's automatic redirect following."""
+
+    def redirect_request(self, *args, **kwargs):  # noqa: ARG002
+        return None
+
+
+class _PinnedHTTPSConnection(http.client.HTTPSConnection):
+    def __init__(self, host: str, *args, pinned_ip: str, **kwargs):
+        super().__init__(host, *args, **kwargs)
+        self._pinned_ip = pinned_ip
+
+    def connect(self):
+        sock = socket.create_connection(
+            (self._pinned_ip, self.port), timeout=self.timeout
+        )
+        if self._tunnel_host:
+            self.sock = sock
+            self._tunnel()
+        # SNI + cert validation use the original hostname, NOT the IP
+        self.sock = self._context.wrap_socket(sock, server_hostname=self.host)
+
+
+class _PinnedHTTPConnection(http.client.HTTPConnection):
+    def __init__(self, host: str, *args, pinned_ip: str, **kwargs):
+        super().__init__(host, *args, **kwargs)
+        self._pinned_ip = pinned_ip
+
+    def connect(self):
+        self.sock = socket.create_connection(
+            (self._pinned_ip, self.port), timeout=self.timeout
+        )
+
+
+def _build_pinned_opener(pinned_ip: str, scheme: str) -> urllib.request.OpenerDirector:
+    """Build an opener that:
+    - suppresses HTTP_PROXY/HTTPS_PROXY env (ProxyHandler({}))
+    - disables urllib's auto-redirect (we walk hops manually)
+    - pins HTTP/S connections to the validated IP
+    """
+    proxy_handler = urllib.request.ProxyHandler({})
+    no_redirect = _NoFollowRedirect()
+
+    if scheme == "https":
+
+        class _Handler(urllib.request.HTTPSHandler):
+            def https_open(self, req):  # noqa: D401
+                return self.do_open(
+                    lambda host, **kw: _PinnedHTTPSConnection(
+                        host, pinned_ip=pinned_ip, **kw
+                    ),
+                    req,
+                )
+
+        pinned_handler = _Handler()
+    else:
+
+        class _Handler(urllib.request.HTTPHandler):
+            def http_open(self, req):  # noqa: D401
+                return self.do_open(
+                    lambda host, **kw: _PinnedHTTPConnection(
+                        host, pinned_ip=pinned_ip, **kw
+                    ),
+                    req,
+                )
+
+        pinned_handler = _Handler()
+
+    return urllib.request.build_opener(proxy_handler, no_redirect, pinned_handler)
+
+
+def safe_fetch(
+    url: str,
+    *,
+    method: str = "GET",
+    max_hops: int = _MAX_REDIRECT_HOPS,
+) -> tuple[bytes | None, dict | None, str | None]:
+    """Fetch ``url`` with manual redirect walking + per-hop revalidation
+    + IP-pinned connection.
+
+    Returns ``(body, headers, None)`` on 2xx, or ``(None, None, error)``
+    on rejection / failure.
+    """
+    visited: list[str] = []
+    current = url
+    for hop in range(max_hops + 1):
+        if current in visited:
+            return None, None, "redirect loop"
+        visited.append(current)
+
+        parsed = urllib.parse.urlsplit(current)
+        if parsed.scheme not in ("http", "https"):
+            return None, None, f"unsupported scheme: {parsed.scheme!r}"
+        if not parsed.hostname:
+            return None, None, f"no hostname in URL: {current}"
+
+        ips, err = _resolve_and_validate(parsed.hostname)
+        if err:
+            return None, None, err
+
+        opener = _build_pinned_opener(ips[0], parsed.scheme)
+        req = urllib.request.Request(
+            current, method=method, headers={"User-Agent": _USER_AGENT}
+        )
+        try:
+            resp = opener.open(req, timeout=_FETCH_TIMEOUT)
+        except urllib.error.HTTPError as e:
+            if e.code in (301, 302, 303, 307, 308):
+                if hop >= max_hops:
+                    return None, None, f"too many redirects (>{max_hops})"
+                location = e.headers.get("Location") if e.headers else None
+                if not location:
+                    return None, None, f"HTTP {e.code} without Location"
+                current = urllib.parse.urljoin(current, location)
+                continue
+            return None, None, f"HTTP {e.code}"
+        except (urllib.error.URLError, OSError, TimeoutError) as e:
+            return None, None, f"fetch error: {e}"
+        body = resp.read(_MAX_RESPONSE_BYTES + 1)
+        if len(body) > _MAX_RESPONSE_BYTES:
+            return None, None, f"response exceeds {_MAX_RESPONSE_BYTES} bytes"
+        return body, dict(resp.headers), None
+    return None, None, f"too many redirects (>{max_hops})"

any2md-1.2.0/any2md/_logging.py

@@ -0,0 +1,61 @@
+"""Stderr/stdout sanitizer + structured-prefix log helpers.
+
+Centralizes control-character + Unicode-spoof stripping for any string
+interpolated from untrusted input (filenames, URLs, exception text,
+HTTP response data). Provides ``warn`` / ``fail`` helpers that wrap
+``sys.stderr.write`` with a fixed two-space indent + uppercase prefix.
+
+Threat model: attacker-supplied tokens reach a terminal via stderr.
+We strip C0/C1 control chars (incl. ANSI escapes), Unicode bidi
+embeds/overrides/isolates, zero-width chars, and the BOM. Newlines
+are preserved by ``_sanitize_log_text`` (multi-line tracebacks remain
+readable) and stripped by ``safe_oneline`` (single-line interpolation).
+"""
+
+from __future__ import annotations
+
+import re
+import sys
+
+_LOG_CONTROL_CHARS_RE = re.compile(
+    r"["
+    r"\x00-\x08\x0b\x0c\x0e-\x1f\x7f-\x9f"  # C0 / C1 control chars
+    r"‪-‮"  # bidi embeds + override
+    r"⁦-⁩"  # bidi isolates
+    r"​-‏"  # zero-width + LRM/RLM
+    r""  # BOM
+    r"]"
+)
+
+_NEWLINE_CR_RE = re.compile(r"[\r\n]")
+
+
+def _sanitize_log_text(s: str) -> str:
+    """Strip control chars + Unicode bidi/zero-width. Preserves newlines."""
+    return _LOG_CONTROL_CHARS_RE.sub("", s)
+
+
+def safe_oneline(s: str) -> str:
+    """Sanitize and collapse all newlines/CRs to single spaces.
+
+    Use for single-line interpolation of untrusted tokens (filenames,
+    URLs, ``str(exception)``) into log messages.
+    """
+    return _NEWLINE_CR_RE.sub(" ", _sanitize_log_text(s))
+
+
+def warn(msg: str, *, prefix: str = "WARN") -> None:
+    """Write ``f'  {prefix}: {sanitized}\\n'`` to stderr.
+
+    Applies ``safe_oneline`` to ``msg`` so embedded newlines/CRs in
+    interpolated values (filenames, exception text, URL components)
+    cannot forge additional log lines. The output is a single line.
+    For multi-line output (e.g., a full traceback), call
+    ``sys.stderr.write`` directly with ``_sanitize_log_text``.
+    """
+    sys.stderr.write(f"  {prefix}: {safe_oneline(msg)}\n")
+
+
+def fail(msg: str, *, prefix: str = "FAIL") -> None:
+    """Same as :func:`warn` with ``prefix='FAIL'``."""
+    warn(msg, prefix=prefix)

{any2md-1.1.0 → any2md-1.2.0}/any2md/cli.py

@@ -6,6 +6,7 @@ import time
 from pathlib import Path
 from typing import Any
 
+from any2md import _logging
 from any2md.config import (
     discover_config,
     extract_document_id_settings,
@@ -236,7 +237,9 @@ def main():
 
     if args.meta_file is not None:
         if not args.meta_file.is_file():
-            print(f"Error: --meta-file not found: {args.meta_file}", file=sys.stderr)
+            sys.stderr.write(
+                f"Error: --meta-file not found: {_logging.safe_oneline(str(args.meta_file))}\n"
+            )
             sys.exit(1)
         cfg = load_toml(args.meta_file)
         overrides = _deep_merge_overrides(overrides, extract_meta_overrides(cfg))
@@ -252,7 +255,7 @@ def main():
     try:
         cli_meta = parse_meta_args(args.meta)
     except ValueError as e:
-        print(f"Error: {e}", file=sys.stderr)
+        sys.stderr.write(f"Error: {_logging.safe_oneline(str(e))}\n")
         sys.exit(1)
     overrides = _deep_merge_overrides(overrides, cli_meta)
     overrides = filter_reserved_overrides(
@@ -319,7 +322,7 @@ def main():
             if not p.is_absolute():
                 p = Path.cwd() / p
             if not p.exists():
-                print(f"  NOT FOUND: {f}", file=sys.stderr)
+                _logging.fail(f"{f}", prefix="NOT FOUND")
                 continue
             if p.is_dir():
                 glob_method = p.rglob if args.recursive else p.glob
@@ -332,12 +335,14 @@ def main():
                 )
                 continue
             if p.suffix.lower() not in SUPPORTED_EXTENSIONS:
-                print(f"  UNSUPPORTED FORMAT: {f}", file=sys.stderr)
+                _logging.fail(f"{f}", prefix="UNSUPPORTED FORMAT")
                 continue
             file_paths.append(p)
     elif args.input_dir:
         if not args.input_dir.is_dir():
-            print(f"Error: not a directory: {args.input_dir}", file=sys.stderr)
+            sys.stderr.write(
+                f"Error: not a directory: {_logging.safe_oneline(str(args.input_dir))}\n"
+            )
             sys.exit(1)
         glob_method = args.input_dir.rglob if args.recursive else args.input_dir.glob
         file_paths = sorted(
@@ -393,7 +398,7 @@ def main():
         try:
             file_size = file_path.stat().st_size
         except OSError as e:
-            print(f"  FAIL: {file_path.name} -- {e}", file=sys.stderr)
+            _logging.fail(f"{file_path.name} -- {e}")
             fail += 1
             continue
 

{any2md-1.1.0 → any2md-1.2.0}/any2md/config.py

@@ -5,25 +5,16 @@ is treated as frontmatter overrides (deep-merged below ``--meta-file``
 and CLI ``--meta`` arguments). The ``[document_id]`` table provides
 ``publisher_prefix`` / ``type_code`` overrides for ``--auto-id``.
 
-TOML parsing uses stdlib ``tomllib`` on Python 3.11+. On older
-interpreters we fall back to the optional ``tomli`` package; if neither
-is importable, ``load_toml`` returns ``{}`` and config is silently
-disabled (no hard error — config is opt-in convenience).
+TOML parsing uses stdlib ``tomllib`` (any2md requires Python 3.11+).
 """
 
 from __future__ import annotations
 
-import sys
+import tomllib
 from pathlib import Path
 from typing import Any
 
-if sys.version_info >= (3, 11):
-    import tomllib
-else:  # pragma: no cover - exercised only on Python 3.10
-    try:
-        import tomli as tomllib  # type: ignore[import-not-found,no-redef]
-    except ImportError:
-        tomllib = None  # type: ignore[assignment]
+from any2md import _logging
 
 
 def load_toml(path: Path) -> dict[str, Any]:
@@ -33,12 +24,13 @@ def load_toml(path: Path) -> dict[str, Any]:
     not block conversion. Callers that need strict validation should
     parse the file themselves.
     """
-    if tomllib is None:  # pragma: no cover - 3.10 without tomli
-        return {}
     try:
         with open(path, "rb") as f:
             return tomllib.load(f)
-    except (OSError, ValueError):
+    except FileNotFoundError:
+        return {}  # silent — discovery walks ancestors and most won't have one
+    except (OSError, ValueError) as e:
+        _logging.warn(f"failed to parse {path}: {e}")
         return {}
 
 

{any2md-1.1.0 → any2md-1.2.0}/any2md/converters/__init__.py

@@ -1,8 +1,8 @@
 """Converter dispatcher for any2md."""
 
-import sys
 from pathlib import Path
 
+from any2md import _logging
 from any2md.pipeline import PipelineOptions
 
 SUPPORTED_EXTENSIONS = {".pdf", ".docx", ".html", ".htm", ".txt"}
@@ -84,5 +84,5 @@ def convert_file(
         from any2md.converters.txt import convert_txt
 
         return convert_txt(file_path, output_dir, options=options, force=force)
-    print(f"  UNSUPPORTED: {file_path.name} (no converter for {ext})", file=sys.stderr)
+    _logging.fail(f"{file_path.name} (no converter for {ext})", prefix="UNSUPPORTED")
     return False