refactor: harmonise with platform conventions

- __init__: use PackageNotFoundError instead of bare Exception
- reporter: expose public console (record=True) and save_report(path)
  supporting .txt/.svg/.html (unknown ext falls back to plain text)
- cli: import console/save_report from reporter; remove _save_report()
- tests: update version-fallback test; replace JSON save test with
  Rich-output save test matching new save_report() contract

Author: t0kubetsu

subdomainenum/__init__.py

@@ -2,11 +2,11 @@
 
 from __future__ import annotations
 
-try:
-    from importlib.metadata import version
+from importlib.metadata import PackageNotFoundError, version
 
+try:
     __version__ = version("subdomainenum")
-except Exception:
+except PackageNotFoundError:  # pragma: no cover – only when package not installed
     __version__ = "0.14.0"
 
 # NullHandler so library users who have not configured logging

subdomainenum/cli.py

@@ -33,15 +33,14 @@
 from subdomainenum.constants import ACTIVE_TOOLS, detect_tools, get_install_hint
 from subdomainenum.debug_logger import DebugLogger
 from subdomainenum.models import EnumMode
-from subdomainenum.reporter import print_report, to_dict
+from subdomainenum.reporter import console, print_report, save_report, to_dict
 
 app = typer.Typer(
     name="subdomainenum",
     help="Passive and active subdomain enumeration for a target domain.",
     add_completion=False,
 )
 
-_console = Console(stderr=False)
 _err = Console(stderr=True)
 
 
@@ -194,7 +193,7 @@ def _progress_cb(msg: str) -> None:
             report = assess(domain, **assess_kwargs)
         except Exception as exc:
             if json_output:
-                _console.print(json.dumps({"error": str(exc)}, indent=2))
+                console.print(json.dumps({"error": str(exc)}, indent=2))
             else:
                 _err.print(f"[red]Error:[/red] {exc}")
             raise typer.Exit(code=1)
@@ -208,10 +207,15 @@ def _progress_cb(msg: str) -> None:
         _print_json(report)
         return
 
-    print_report(report, console=_console)
+    print_report(report, console=console)
 
     if output:
-        _save_report(report, output)
+        try:
+            save_report(output)
+            console.print(f"[dim]Report saved to[/dim] {output}")
+        except (ValueError, OSError) as exc:
+            _err.print(f"[red]Error:[/red] Cannot write to {output!r}: {exc}")
+            raise typer.Exit(code=1)
 
 
 # ---------------------------------------------------------------------------
@@ -233,7 +237,7 @@ def info() -> None:
             f"[{style}]{'yes' if avail else 'no'}[/{style}]",
             get_install_hint(name) if not avail else "",
         )
-    _console.print(table)
+    console.print(table)
 
 
 # ---------------------------------------------------------------------------
@@ -246,36 +250,7 @@ def _print_json(report) -> None:
 
     :param report: :class:`~subdomainenum.models.EnumReport` to serialise.
     """
-    _console.print(json.dumps(to_dict(report), indent=2))
-
-
-def _save_report(report, path: str) -> None:
-    """Render *report* to a file at *path*.
-
-    The output format is inferred from the file extension:
-    ``.txt`` → plain text (no ANSI codes), ``.svg`` → SVG image,
-    ``.html`` → self-contained HTML page.  Any other extension is
-    treated as plain text.
-
-    :param report: :class:`~subdomainenum.models.EnumReport` to render.
-    :param path: Destination file path.
-    """
-    from rich.console import Console as RichConsole
-
-    ext = Path(path).suffix.lower()
-
-    rec_console = RichConsole(record=True, highlight=False, width=120)
-    print_report(report, console=rec_console)
-
-    if ext == ".svg":
-        content = rec_console.export_svg(title=f"subdomainenum — {report.domain}")
-    elif ext == ".html":
-        content = rec_console.export_html(inline_styles=True)
-    else:
-        content = rec_console.export_text()
-
-    Path(path).write_text(content, encoding="utf-8")
-    _console.print(f"[dim]Report saved to[/dim] {path}")
+    console.print(json.dumps(to_dict(report), indent=2))
 
 
 if __name__ == "__main__":  # pragma: no cover

subdomainenum/reporter.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import json
+import os
 from pathlib import Path
 
 from rich.console import Console, Group
@@ -14,7 +15,11 @@
 from subdomainenum.models import EnumMode, EnumReport, Status, ToolResult
 from subdomainenum.verdict import build_verdict
 
-_console = Console()
+# Module-level console; record=True enables save_report() export.
+# The public alias ``console`` is imported by cli.py so that all
+# terminal output flows through the same recorded stream.
+_console = Console(record=True)
+console = _console
 
 
 _SECTION_PANEL_KWARGS = dict(style="white", padding=(0, 1))
@@ -220,11 +225,38 @@ def print_report(report: EnumReport, *, console: Console | None = None) -> None:
     con.rule("[dim]End of Report[/dim]")
 
 
-def save_report(report: EnumReport, path: str | Path) -> None:
-    """Save the report as JSON to *path*.
+_FORMAT_BY_EXT: dict[str, str] = {
+    ".txt": "text",
+    ".text": "text",
+    ".svg": "svg",
+    ".html": "html",
+    ".htm": "html",
+}
 
-    :param report: Completed enumeration report.
-    :param path: Destination file path.
+
+def save_report(path: str) -> None:
+    """Save the recorded console output to *path*.
+
+    The export format is inferred from the file extension:
+
+    * ``.txt`` / ``.text`` → plain text (no ANSI codes)
+    * ``.svg``             → SVG image
+    * ``.html`` / ``.htm`` → self-contained HTML page
+
+    Must be called **after** :func:`print_report` because Rich only
+    captures output when :class:`~rich.console.Console` is created with
+    ``record=True``, which is already set on the module-level
+    :data:`console` instance.
+
+    :param path: Destination file path, e.g. ``"report.svg"``.
+    :raises ValueError: If the extension is not one of the supported values.
+    :raises OSError: If the file cannot be written.
     """
-    data = to_dict(report)
-    Path(path).write_text(json.dumps(data, indent=2), encoding="utf-8")
+    ext = os.path.splitext(path)[1].lower()
+    fmt = _FORMAT_BY_EXT.get(ext, "text")
+    if fmt == "svg":
+        console.save_svg(path, clear=False)
+    elif fmt == "html":
+        console.save_html(path, clear=False)
+    else:
+        console.save_text(path, clear=False)

tests/test_init.py

@@ -8,10 +8,12 @@
 
 
 def test_version_fallback_when_metadata_unavailable() -> None:
-    """Cover lines 9-10: the except branch when importlib.metadata.version raises."""
+    """Cover the except branch when importlib.metadata.version raises PackageNotFoundError."""
+    from importlib.metadata import PackageNotFoundError
+
     saved = sys.modules.pop("subdomainenum", None)
     try:
-        with patch("importlib.metadata.version", side_effect=Exception("pkg not found")):
+        with patch("importlib.metadata.version", side_effect=PackageNotFoundError("subdomainenum")):
             fresh = importlib.import_module("subdomainenum")
         assert fresh.__version__ == "0.14.0"
     finally:

tests/test_reporter.py

@@ -225,9 +225,20 @@ def test_sources_timed_out_flag_rendered(self) -> None:
 
 
 class TestSaveReport:
-    def test_save_report_writes_json(self, tmp_path) -> None:
-        out = tmp_path / "report.json"
-        save_report(_make_report(), out)
+    def test_save_report_writes_plain_text(self, tmp_path) -> None:
+        from subdomainenum.reporter import console
+
+        out = tmp_path / "report.txt"
+        # Render into the module-level console so there is recorded content to save.
+        print_report(_make_report(), console=console)
+        save_report(str(out))
+        assert out.exists()
+        assert "example.com" in out.read_text()
+
+    def test_save_report_writes_text_for_unknown_ext(self, tmp_path) -> None:
+        from subdomainenum.reporter import console
+
+        out = tmp_path / "report.log"
+        print_report(_make_report(), console=console)
+        save_report(str(out))
         assert out.exists()
-        data = json.loads(out.read_text())
-        assert data["domain"] == "example.com"