smart-log-reader 1.0.0__tar.gz

smart_log_reader-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ABHIRAMSSGIT
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

smart_log_reader-1.0.0/PKG-INFO

@@ -0,0 +1,117 @@
+Metadata-Version: 2.1
+Name: smart-log-reader
+Version: 1.0.0
+Summary: Intelligent, extensible log reader and analyzer with color-coded output and smart error grouping.
+Author-email: ABHINAVSS <abhinavssabhi123@gmail.com>
+License: MIT
+Keywords: log,parser,analyzer,cli,devops
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: System :: Logging
+Classifier: Topic :: Utilities
+Classifier: Environment :: Console
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer[all]>=0.9
+Requires-Dist: rich>=13.0
+Requires-Dist: python-dateutil>=2.8
+Requires-Dist: rapidfuzz>=3.0
+
+# 🐍 smart-log-reader
+
+**Stop grep-ing blindly.**  
+smart-log-reader is an intelligent, terminal-first log analyzer that instantly parses massive log files, groups similar errors using fuzzy matching, and outputs beautifully formatted, color-coded summaries directly in your terminal.
+
+When the terminal isn't enough, export a fully interactive HTML dashboard and serve it securely from your remote server to your local machine via an SSH tunnel.
+
+## 🚀 Installation
+
+Because this is a standalone CLI tool, **do not install it globally with pip**.  
+Use `pipx` to install it in an isolated environment so it never conflicts with your system dependencies.
+
+```bash
+pipx install smart-log-reader
+````
+
+## 🔥 Quick Start: Real-World Scenarios
+#### 1. The "Server is on fire" check (Auto-detects format, groups errors)
+```
+smart-log-reader -f /var/log/syslog -l ERROR
+```
+
+#### 2. The "Odoo is crashing" audit (Filter by time and keyword)
+```
+smart-log-reader -f odoo-server.log -t odoo -k "psycopg2" -s "2024-03-05 10:00:00"
+```
+
+#### 3. Generate an interactive HTML report and serve it securely
+```
+smart-log-reader -f production.log -t python -x html --serve
+```
+
+## ✨ Core Features
+
+- **Format Auto-Detection**  
+  Automatically recognizes Python, Django, Flask, Odoo, Nginx, Apache, PostgreSQL, MySQL, and JSON-line logs.
+
+- **Intelligent Error Grouping**  
+  Uses `rapidfuzz` (85% threshold) to group thousands of repetitive tracebacks into unique "Core Issues", showing you exactly what broke and how often.
+
+- **Zero-Memory Streaming**  
+  Processes multi-gigabyte log files line-by-line without eating up your server's RAM.
+
+- **Multi-line Unification**  
+  Automatically stitches stack traces and JSON payloads back together into single, readable entries.
+
+## 🛡️ The Killer Feature: Secure HTML Export & Tunneling
+
+When debugging remote production servers, downloading gigabytes of logs is tedious and risky.  
+smart-log-reader solves this natively.
+
+With `--serve`, it:
+
+- generates a self-contained HTML dashboard
+- starts a minimal, **localhost-only** HTTP server on the production machine
+- lets you view it securely via SSH tunnel
+
+**Your log data never leaves the server.**
+
+### How to use it
+
+**On the remote server:**
+
+```bash
+smart-log-reader -f /var/log/nginx/error.log -x html --serve --port 8080
+```
+
+**On your local machine:**
+
+```bash
+ssh -L 8080:127.0.0.1:8080 your-user@your-remote-server.com
+```
+
+Then open in your browser:  
+**http://localhost:8080/report_name.html**
+
+> **Alternative (LAN / VPN only):** use `--serve-public` → gets a token-protected URL, no SSH tunnel needed.
+
+## 🛠️ CLI Reference
+
+| Flag              | Description                                                                 |
+|-------------------|-----------------------------------------------------------------------------|
+| `-f, --file`      | **(Required)** Path to the log file                                        |
+| `-t, --log-type`  | Force parser: `auto`, `python`, `django`, `flask`, `odoo`, `nginx`, `apache`, `postgresql`, `mysql`, `mariadb`, `jsonline` |
+| `-l, --level`     | Filter by severity: `ALL`, `ERROR`, `WARNING`, `INFO`, `DEBUG`             |
+| `-k, --keyword`   | Filter logs containing a specific string or regex pattern                  |
+| `-s, --start-time`| Start time filter (e.g. `YYYY-MM-DD HH:MM:SS`)                             |
+| `-e, --end-time`  | End time filter                                                            |
+| `-x, --export`    | Export format: `none`, `json`, `html`                                      |
+| `--serve`         | Starts a localhost-only HTTP server for the HTML export                    |
+| `--serve-public`  | **[LAN/VPN ONLY]** Binds server to 0.0.0.0 with secure URL token           |
+| `-p, --port`      | Specify port for the HTTP server (defaults to random available port)       |
+| `-g, --no-group-errors` | Disables fuzzy error grouping                                       |
+
+## License
+
+[MIT](LICENSE)

smart_log_reader-1.0.0/README.md

@@ -0,0 +1,97 @@
+# 🐍 smart-log-reader
+
+**Stop grep-ing blindly.**  
+smart-log-reader is an intelligent, terminal-first log analyzer that instantly parses massive log files, groups similar errors using fuzzy matching, and outputs beautifully formatted, color-coded summaries directly in your terminal.
+
+When the terminal isn't enough, export a fully interactive HTML dashboard and serve it securely from your remote server to your local machine via an SSH tunnel.
+
+## 🚀 Installation
+
+Because this is a standalone CLI tool, **do not install it globally with pip**.  
+Use `pipx` to install it in an isolated environment so it never conflicts with your system dependencies.
+
+```bash
+pipx install smart-log-reader
+````
+
+## 🔥 Quick Start: Real-World Scenarios
+#### 1. The "Server is on fire" check (Auto-detects format, groups errors)
+```
+smart-log-reader -f /var/log/syslog -l ERROR
+```
+
+#### 2. The "Odoo is crashing" audit (Filter by time and keyword)
+```
+smart-log-reader -f odoo-server.log -t odoo -k "psycopg2" -s "2024-03-05 10:00:00"
+```
+
+#### 3. Generate an interactive HTML report and serve it securely
+```
+smart-log-reader -f production.log -t python -x html --serve
+```
+
+## ✨ Core Features
+
+- **Format Auto-Detection**  
+  Automatically recognizes Python, Django, Flask, Odoo, Nginx, Apache, PostgreSQL, MySQL, and JSON-line logs.
+
+- **Intelligent Error Grouping**  
+  Uses `rapidfuzz` (85% threshold) to group thousands of repetitive tracebacks into unique "Core Issues", showing you exactly what broke and how often.
+
+- **Zero-Memory Streaming**  
+  Processes multi-gigabyte log files line-by-line without eating up your server's RAM.
+
+- **Multi-line Unification**  
+  Automatically stitches stack traces and JSON payloads back together into single, readable entries.
+
+## 🛡️ The Killer Feature: Secure HTML Export & Tunneling
+
+When debugging remote production servers, downloading gigabytes of logs is tedious and risky.  
+smart-log-reader solves this natively.
+
+With `--serve`, it:
+
+- generates a self-contained HTML dashboard
+- starts a minimal, **localhost-only** HTTP server on the production machine
+- lets you view it securely via SSH tunnel
+
+**Your log data never leaves the server.**
+
+### How to use it
+
+**On the remote server:**
+
+```bash
+smart-log-reader -f /var/log/nginx/error.log -x html --serve --port 8080
+```
+
+**On your local machine:**
+
+```bash
+ssh -L 8080:127.0.0.1:8080 your-user@your-remote-server.com
+```
+
+Then open in your browser:  
+**http://localhost:8080/report_name.html**
+
+> **Alternative (LAN / VPN only):** use `--serve-public` → gets a token-protected URL, no SSH tunnel needed.
+
+## 🛠️ CLI Reference
+
+| Flag              | Description                                                                 |
+|-------------------|-----------------------------------------------------------------------------|
+| `-f, --file`      | **(Required)** Path to the log file                                        |
+| `-t, --log-type`  | Force parser: `auto`, `python`, `django`, `flask`, `odoo`, `nginx`, `apache`, `postgresql`, `mysql`, `mariadb`, `jsonline` |
+| `-l, --level`     | Filter by severity: `ALL`, `ERROR`, `WARNING`, `INFO`, `DEBUG`             |
+| `-k, --keyword`   | Filter logs containing a specific string or regex pattern                  |
+| `-s, --start-time`| Start time filter (e.g. `YYYY-MM-DD HH:MM:SS`)                             |
+| `-e, --end-time`  | End time filter                                                            |
+| `-x, --export`    | Export format: `none`, `json`, `html`                                      |
+| `--serve`         | Starts a localhost-only HTTP server for the HTML export                    |
+| `--serve-public`  | **[LAN/VPN ONLY]** Binds server to 0.0.0.0 with secure URL token           |
+| `-p, --port`      | Specify port for the HTTP server (defaults to random available port)       |
+| `-g, --no-group-errors` | Disables fuzzy error grouping                                       |
+
+## License
+
+[MIT](LICENSE)

smart_log_reader-1.0.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "smart-log-reader"
+version = "1.0.0"
+description = "Intelligent, extensible log reader and analyzer with color-coded output and smart error grouping."
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.8"
+authors = [{name = "ABHINAVSS", email='abhinavssabhi123@gmail.com'}]
+keywords = ["log", "parser", "analyzer", "cli", "devops"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Topic :: System :: Logging",
+    "Topic :: Utilities",
+    "Environment :: Console",
+]
+dependencies = [
+    "typer[all]>=0.9",
+    "rich>=13.0",
+    "python-dateutil>=2.8",
+    "rapidfuzz>=3.0",
+]
+
+[project.scripts]
+smart-log-reader = "smart_log_reader.cli:app"
+
+[tool.setuptools.packages.find]
+include = ["smart_log_reader*"]

smart_log_reader-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

smart_log_reader-1.0.0/setup.py

@@ -0,0 +1,2 @@
+from setuptools import setup
+setup()

smart_log_reader-1.0.0/smart_log_reader/analyzer.py

@@ -0,0 +1,118 @@
+"""Log analysis: filtering, fuzzy error grouping, statistics."""
+from __future__ import annotations
+from datetime import datetime
+from typing import Iterator, Optional
+
+from rapidfuzz import fuzz
+
+from .models import AnalysisResult, ErrorGroup, LogEntry
+
+SIMILARITY_THRESHOLD = 85
+
+
+def _core_issue(msg: str) -> str:
+    """Extract first meaningful line as core issue."""
+    for line in msg.split("\n"):
+        s = line.strip()
+        if s:
+            return s[:200]
+    return msg[:200]
+
+
+def filter_entries(
+    entries: Iterator[LogEntry],
+    level: str = "ALL",
+    keyword: Optional[str] = None,
+    start_time: Optional[datetime] = None,
+    end_time: Optional[datetime] = None,
+) -> Iterator[LogEntry]:
+    """Apply level, keyword, and time-range filters."""
+    import re
+    kw_re = re.compile(keyword, re.IGNORECASE) if keyword else None
+
+    for e in entries:
+        if level != "ALL" and e.level != level.upper():
+            continue
+        if start_time and e.timestamp and e.timestamp < start_time:
+            continue
+        if end_time and e.timestamp and e.timestamp > end_time:
+            continue
+        if kw_re and not kw_re.search(e.message) and not kw_re.search(e.full_entry):
+            continue
+        yield e
+
+
+def group_errors(entries: list[LogEntry], threshold: int = SIMILARITY_THRESHOLD) -> list[ErrorGroup]:
+    """Group similar ERROR entries using fuzzy matching."""
+    errors = [e for e in entries if e.level == "ERROR"]
+    if not errors:
+        return []
+
+    groups: list[ErrorGroup] = []
+    for entry in errors:
+        core = _core_issue(entry.message)
+        matched = False
+        for g in groups:
+            if fuzz.token_sort_ratio(core, g.core_issue) >= threshold:
+                g.count += 1
+                g.entries.append(entry)
+                if entry.timestamp:
+                    if g.first_seen is None or entry.timestamp < g.first_seen:
+                        g.first_seen = entry.timestamp
+                    if g.last_seen is None or entry.timestamp > g.last_seen:
+                        g.last_seen = entry.timestamp
+                entry.category = g.core_issue[:80]
+                entry.occurrence_count = g.count
+                matched = True
+                break
+        if not matched:
+            g = ErrorGroup(
+                representative=entry.message,
+                core_issue=core,
+                count=1,
+                first_seen=entry.timestamp,
+                last_seen=entry.timestamp,
+                entries=[entry],
+            )
+            groups.append(g)
+            entry.category = core[:80]
+
+    # Back-fill occurrence counts
+    for g in groups:
+        for e in g.entries:
+            e.occurrence_count = g.count
+    groups.sort(key=lambda g: g.count, reverse=True)
+    return groups
+
+
+def analyze(
+    entries: list[LogEntry],
+    do_group: bool = True,
+    detected_format: str = "generic",
+) -> AnalysisResult:
+    """Build full analysis result from filtered entries."""
+    result = AnalysisResult(detected_format=detected_format)
+    result.entries = entries
+    result.parsed_entries = len(entries)
+
+    for e in entries:
+        result.total_lines += 1
+        lvl = e.level
+        if lvl == "ERROR":
+            result.error_count += 1
+        elif lvl == "WARNING":
+            result.warning_count += 1
+        elif lvl == "INFO":
+            result.info_count += 1
+        elif lvl == "DEBUG":
+            result.debug_count += 1
+        if e.timestamp:
+            if result.time_span_start is None or e.timestamp < result.time_span_start:
+                result.time_span_start = e.timestamp
+            if result.time_span_end is None or e.timestamp > result.time_span_end:
+                result.time_span_end = e.timestamp
+
+    if do_group:
+        result.error_groups = group_errors(entries)
+        result.unique_errors = len(result.error_groups)
+    return result

smart_log_reader-1.0.0/smart_log_reader/base.py

@@ -0,0 +1,98 @@
+"""Base parser with multi-line handling."""
+from __future__ import annotations
+import re
+from datetime import datetime
+from typing import Iterator, Optional, TextIO
+
+from dateutil import parser as dtparser
+
+from .models import LogEntry
+
+# Broad pattern that matches most timestamp-prefixed log lines
+_TIMESTAMP_START = re.compile(
+    r"^\d{4}[-/]\d{2}[-/]\d{2}[T ]\d{2}:\d{2}"  # ISO-ish
+    r"|^\w{3}\s+\d{1,2}\s+\d{2}:\d{2}:\d{2}"      # syslog
+    r"|^\[\d{4}[-/]\d{2}[-/]\d{2}"                  # bracket-wrapped
+)
+
+LEVEL_NORM = {
+    "CRITICAL": "ERROR", "FATAL": "ERROR", "SEVERE": "ERROR", "PANIC": "ERROR",
+    "WARN": "WARNING", "WARNING": "WARNING",
+    "ERROR": "ERROR", "INFO": "INFO", "DEBUG": "DEBUG",
+    "NOTICE": "INFO", "LOG": "INFO", "NOTE": "INFO",
+    "DEBUG1": "DEBUG", "DEBUG2": "DEBUG", "DEBUG3": "DEBUG",
+    "DEBUG4": "DEBUG", "DEBUG5": "DEBUG",
+}
+
+
+def normalize_level(raw: str) -> str:
+    return LEVEL_NORM.get(raw.upper(), raw.upper())
+
+
+def safe_parse_ts(text: str) -> Optional[datetime]:
+    """Try to parse a timestamp string, return None on failure."""
+    if not text:
+        return None
+    try:
+        return dtparser.parse(text, fuzzy=True)
+    except (ValueError, OverflowError):
+        return None
+
+
+class BaseParser:
+    """Base class all format parsers extend."""
+
+    name: str = "generic"
+    # Subclasses override with compiled regex
+    primary_pattern: Optional[re.Pattern] = None
+    # How confident is this parser for a sample line (0-1)
+
+    @classmethod
+    def confidence(cls, sample_lines: list[str]) -> float:
+        """Return 0-1 confidence that these lines match this parser."""
+        if cls.primary_pattern is None:
+            return 0.05  # generic fallback
+        hits = sum(1 for l in sample_lines if cls.primary_pattern.search(l))
+        return hits / max(len(sample_lines), 1)
+
+    def parse_line(self, line: str) -> Optional[LogEntry]:
+        """Parse a single line. Return None if it's a continuation."""
+        return LogEntry(raw=line, message=line.strip(), full_entry=line)
+
+    def is_continuation(self, line: str) -> bool:
+        """Return True if line is a continuation of the previous entry (stack trace etc)."""
+        if not line.strip():
+            return True
+        return not bool(_TIMESTAMP_START.match(line))
+
+    def stream_entries(self, fh: TextIO) -> Iterator[LogEntry]:
+        """Stream parsed entries from a file handle, merging multi-line entries."""
+        current: Optional[LogEntry] = None
+        line_num = 0
+
+        for raw_line in fh:
+            line_num += 1
+            # Try to parse as new entry
+            if not self.is_continuation(raw_line):
+                parsed = self.parse_line(raw_line)
+                if parsed is not None:
+                    if current is not None:
+                        yield current
+                    parsed.line_number = line_num
+                    current = parsed
+                    continue
+
+            # It's a continuation line — append to current
+            if current is not None:
+                current.full_entry += raw_line
+                # Append meaningful content to message
+                stripped = raw_line.strip()
+                if stripped:
+                    current.message += "\n" + stripped
+            else:
+                # Orphan continuation — emit as standalone
+                entry = LogEntry(raw=raw_line, message=raw_line.strip(), full_entry=raw_line, line_number=line_num)
+                yield entry
+
+        if current is not None:
+            yield current

smart_log_reader-1.0.0/smart_log_reader/cli.py

@@ -0,0 +1,187 @@
+"""CLI entry point using Typer."""
+from __future__ import annotations
+from pathlib import Path
+from typing import Optional
+
+import typer
+from dateutil import parser as dtparser
+from rich.console import Console
+
+from .analyzer import analyze, filter_entries
+from .display import display
+from .registry import detect_format, get_parser
+
+app = typer.Typer(
+    name="smart-log-reader",
+    help="Intelligent log reader and analyzer with color-coded output and smart error grouping.",
+    add_completion=False,
+)
+
+LOG_TYPES = ["auto", "python", "django", "flask", "odoo", "nginx", "apache",
+             "postgresql", "mysql", "mariadb", "generic", "jsonline"]
+LEVELS = ["ALL", "ERROR", "WARNING", "INFO", "DEBUG"]
+EXPORT_FORMATS = ["none", "json", "html"]
+
+
+def _parse_time(val):
+    if not val:
+        return None
+    try:
+        return dtparser.parse(val, fuzzy=True)
+    except (ValueError, OverflowError):
+        raise typer.BadParameter(f"Cannot parse datetime: {val}")
+
+
+def _safe_output_path(log_file: Path, fmt: str, user_output: Optional[Path]) -> Path:
+    """
+    Resolve the output path for export files.
+
+    Priority:
+      1. User explicitly provided --output  → honour it as-is (their responsibility).
+      2. Otherwise                          → write to ~/.smart-log-reader/reports/
+                                             with a timestamped name so we never hit
+                                             PermissionError on /var/log/* or similar.
+    """
+    if user_output:
+        return user_output
+
+    from .html_export import safe_report_path
+    ext = {"json": ".json", "html": ".html"}.get(fmt, ".out")
+    return safe_report_path(log_file, suffix=ext)
+
+
+def version_callback(value):
+    if value:
+        import importlib.metadata
+        try:
+            ver = importlib.metadata.version("smart-log-reader")
+        except importlib.metadata.PackageNotFoundError:
+            ver = "unknown"
+        typer.echo(f"smart-log-reader v{ver}")
+        raise typer.Exit()
+
+
+@app.command()
+def main(
+    file: Path = typer.Option(..., "--file", "-f", help="Path to the log file."),
+    log_type: str = typer.Option("auto", "--log-type", "-t",
+                                 help=f"Log format: {', '.join(LOG_TYPES)}"),
+    level: str = typer.Option("ALL", "--level", "-l",
+                               help=f"Filter by level: {', '.join(LEVELS)}"),
+    keyword: Optional[str] = typer.Option(None, "--keyword", "-k",
+                                           help="Keyword or regex filter."),
+    start_time: Optional[str] = typer.Option(None, "--start-time", "-s",
+                                              help="Start time filter. (YYYY-MM-DD HH:MM:SS)"),
+    end_time: Optional[str] = typer.Option(None, "--end-time", "-e",
+                                            help="End time filter. (YYYY-MM-DD HH:MM:SS)"),
+    export: str = typer.Option("none", "--export", "-x",
+                                help=f"Export format: {', '.join(EXPORT_FORMATS)}"),
+    output: Optional[Path] = typer.Option(
+        None, "--output", "-o",
+        help="Custom output path. Defaults to ~/.smart-log-reader/reports/<name>_<ts>.<ext>",
+    ),
+    group_errors: bool = typer.Option(True, "--group-errors/--no-group-errors", "-g",
+                                       help="Enable error grouping."),
+    color: bool = typer.Option(True, "--color/--no-color", help="Color output."),
+
+    # ── serving flags ─────────────────────────────────────────────────────────
+    serve: bool = typer.Option(
+        False, "--serve",
+        help=(
+            "After HTML export, start a localhost-only HTTP server. "
+            "Access via SSH tunnel: ssh -L <port>:127.0.0.1:<port> user@server"
+        ),
+    ),
+    serve_public: bool = typer.Option(
+        False, "--serve-public",
+        help=(
+            "[INSECURE — LAN/VPN only] Bind to 0.0.0.0 with a one-time token. "
+            "Use only inside a trusted network. Never on a public internet-facing server."
+        ),
+    ),
+    port: int = typer.Option(0, "--port", "-p",
+                              help="Port for --serve / --serve-public (0 = auto)."),
+
+    version: Optional[bool] = typer.Option(None, "--version", "-v",
+                                            callback=version_callback, is_eager=True),
+):
+    """Parse, analyze, and display log files with smart error grouping."""
+    console = Console(force_terminal=color, no_color=not color)
+
+    # ── validation ─────────────────────────────────────────────────────────────
+    if not file.exists():
+        console.print(f"[red]Error: File not found: {file}[/red]")
+        raise typer.Exit(1)
+
+    if log_type not in LOG_TYPES:
+        console.print(f"[red]Invalid log type. Choose from: {', '.join(LOG_TYPES)}[/red]")
+        raise typer.Exit(1)
+
+    if export not in EXPORT_FORMATS:
+        console.print(f"[red]Invalid export format. Choose from: {', '.join(EXPORT_FORMATS)}[/red]")
+        raise typer.Exit(1)
+
+    if (serve or serve_public) and export not in ("html", "none"):
+        console.print("[yellow]--serve requires HTML export. Switching --export to html.[/yellow]")
+    if serve or serve_public:
+        export = "html"
+
+    if serve and serve_public:
+        console.print("[red]Use either --serve (localhost) or --serve-public, not both.[/red]")
+        raise typer.Exit(1)
+
+    # ── parse & filter ─────────────────────────────────────────────────────────
+    fmt = log_type if log_type != "auto" else detect_format(str(file))
+    console.print(f"[dim]Using parser: {fmt}[/dim]")
+
+    parser = get_parser(fmt)
+    st = _parse_time(start_time)
+    et = _parse_time(end_time)
+
+    with open(file, "r", errors="replace") as fh:
+        raw_entries = parser.stream_entries(fh)
+        filtered    = filter_entries(raw_entries, level=level, keyword=keyword,
+                                     start_time=st, end_time=et)
+        entries = list(filtered)
+
+    if not entries:
+        console.print("[yellow]No log entries matched your filters.[/yellow]")
+        raise typer.Exit(0)
+
+    result = analyze(entries, do_group=group_errors, detected_format=fmt)
+
+    # ── terminal display ───────────────────────────────────────────────────────
+    display(result, console=console)
+
+    # ── export ─────────────────────────────────────────────────────────────────
+    if export == "none":
+        return
+
+    out_path = _safe_output_path(file, export, output)
+
+    if export == "json":
+        from .json_export import export_json
+        export_json(result, out_path)
+        console.print(f"\n[bold green]Exported JSON →[/bold green] {out_path}")
+
+    elif export == "html":
+        from .html_export import export_html, serve_html, prune_old_reports
+
+        export_html(result, out_path)
+        prune_old_reports(keep=20)   # keep the last 20 reports, silently drop older ones
+        console.print(f"\n[bold green]Exported HTML →[/bold green] {out_path}")
+        console.print(f"[dim]Reports folder: {out_path.parent}[/dim]")
+
+        if serve or serve_public:
+            serve_html(out_path, port=port, public=serve_public)
+        else:
+            console.print(
+                "\n[dim]Tip: add [bold]--serve[/bold] to view in a browser via SSH tunnel, "
+                "or copy the file to your local machine with:[/dim]"
+            )
+            console.print(
+                f"[dim cyan]  scp <user>@<server>:{out_path} ~/Downloads/[/dim cyan]"
+            )
+
+
+app()