pagonic 0.5.0__tar.gz

pagonic-0.5.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pagonic contributors
+
+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.

pagonic-0.5.0/PKG-INFO

@@ -0,0 +1,245 @@
+Metadata-Version: 2.4
+Name: pagonic
+Version: 0.5.0
+Summary: A security-aware Python ZIP inspection and safe extraction toolkit.
+Author: Pagonic contributors
+License-Expression: MIT
+Keywords: zip,archive,inspection,safe-extraction,cli
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: System :: Archiving :: Compression
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.1.7
+Requires-Dist: rich>=13.7.0
+Provides-Extra: dev
+Requires-Dist: build>=1.2.0; extra == "dev"
+Requires-Dist: coverage>=7.0.0; extra == "dev"
+Requires-Dist: pytest>=8.3.5; extra == "dev"
+Requires-Dist: pytest-cov>=6.1.1; extra == "dev"
+Requires-Dist: psutil>=5.9.0; extra == "dev"
+Provides-Extra: gui
+Requires-Dist: PyQt6>=6.6.0; extra == "gui"
+Provides-Extra: performance
+Requires-Dist: numpy>=1.24.0; extra == "performance"
+Requires-Dist: psutil>=5.9.0; extra == "performance"
+Dynamic: license-file
+
+# Pagonic
+
+Pagonic is an alpha Python ZIP toolkit focused on safe archive inspection,
+secure extraction, and repeatable local benchmarking. Its main idea is simple:
+
+> Inspect before you extract.
+
+<p align="center">
+  <img src="assets/pagonic-demo.gif" alt="Pagonic inspecting a suspicious ZIP and refusing unsafe automation" width="960">
+</p>
+
+The intended workflow is visible in the demo: inspect the archive, verify it
+against an explicit risk threshold, and let `safe-extract` refuse unsafe input
+before it writes files.
+
+* A core library for inspecting, writing, reading, and validating ZIP archives.
+* A `pagonic` command-line interface for inspect, verify, safe extract, and ZIP utilities.
+* An optional PyQt6 GUI launched with `pagonic-gui`.
+
+This repository contains the `v0.5.0` alpha release. The import package remains
+`Pagonic` for compatibility; the distribution name is `pagonic`. No PyPI or
+TestPyPI package is published, so install from a local checkout or use the
+artifacts attached to the [GitHub release](https://github.com/SetraTheXX/pagonic/releases/tag/v0.5.0).
+
+## Project Story
+
+Pagonic started more than a year ago as one of my earliest software-learning projects. Its first direction was much broader and more experimental: a ZIP/archive engine with compression, extraction, GUI ideas, benchmarking, and performance experiments.
+
+After many iterations, I revised the project direction and narrowed the public scope into something clearer:
+
+> Pagonic is not trying to be another desktop archive manager.
+> It is becoming a security-aware ZIP inspection and safe extraction toolkit.
+
+This `v0.5.0` release builds on the first cleaned-up public direction from
+`v0.4.0`. It keeps the useful ZIP core, CLI, tests, and safety work while making
+the inspection policy, regression corpus, automation examples, package surface,
+and compatibility boundaries explicit.
+
+Pagonic is still evolving, but its purpose is now clearer: inspect first, extract safely.
+
+## Install
+
+No PyPI or TestPyPI package is published for this release, so install from a
+local checkout after cloning the repository.
+
+For CLI-only use from a local checkout:
+
+```bash
+python -m pip install .
+```
+
+For local development:
+
+```bash
+python -m pip install -e .[dev,gui]
+```
+
+For CLI-only development with test dependencies:
+
+```bash
+python -m pip install -e .[dev]
+```
+
+Experimental performance helpers are optional and are not required by inspection
+or safe extraction:
+
+```bash
+python -m pip install -e .[performance]
+```
+
+The GUI is optional. If PyQt6 is not installed, `pagonic-gui` exits with a clear install message.
+
+## CLI Quick Start
+
+```bash
+pagonic --help
+pagonic inspect suspicious.zip
+pagonic inspect suspicious.zip --json
+pagonic inspect suspicious.zip --markdown
+pagonic verify release.zip
+pagonic verify release.zip --max-risk medium
+pagonic safe-extract upload.zip output/
+pagonic safe-extract upload.zip output/ --dry-run
+pagonic list archive.zip --tree
+pagonic compress path/to/file.txt -o archive.zip
+pagonic config list
+```
+
+Use `inspect` before extraction for untrusted ZIP files. `safe-extract` applies
+the inspection gate before writing files, supports `--dry-run`, and refuses ZIP
+entries that use unsupported compression methods.
+
+## Python API Quick Start
+
+```python
+from Pagonic.core.formats.zip_writer import ZipWriter
+from Pagonic.core.formats.zip_reader import ZipReader
+
+writer = ZipWriter("archive.zip", compression_level=6)
+writer.add_file("file.txt")
+writer.finalize()
+
+reader = ZipReader("archive.zip")
+report = reader.inspect()
+
+if report.risk_level in {"ok", "low"}:
+    reader.extract_all("output")
+```
+
+## Project Layout
+
+```text
+Pagonic/          Python package
+tests/            pytest suite
+docs/             public documentation
+examples/         small runnable examples
+pyproject.toml    package metadata and tool config
+```
+
+## Documentation
+
+- [Architecture](docs/architecture.md)
+- [User Guide](docs/user-guide.md)
+- [Inspection Policy Contract](docs/inspection-policy.md)
+- [Inspection JSON Schema Contract](docs/inspection-schema.md)
+- [CI Integration](docs/ci-integration.md)
+- [Package Surface Audit](docs/package-audit.md)
+- [0.5 Migration Notes](docs/migration-0.5.md)
+- [0.5 Release Audit](docs/release-audit-0.5.md)
+- [SARIF Evaluation](docs/sarif-evaluation.md)
+- [ZipHandler Compatibility Policy](docs/zip-handler-compatibility.md)
+- [Developer Guide](docs/developer-guide.md)
+- [0.4 Migration Notes](docs/migration-0.4.md)
+- [Roadmap](docs/roadmap.md)
+- [Changelog](CHANGELOG.md)
+- [Contributing](CONTRIBUTING.md)
+- [Security Policy](SECURITY.md)
+- [Code of Conduct](CODE_OF_CONDUCT.md)
+
+## Contributing
+
+Focused contributions are welcome, especially improvements to inspection
+determinism, security regression coverage, safe extraction policy, CI
+integration, and documentation. Read [CONTRIBUTING.md](CONTRIBUTING.md), check
+[the 0.5 roadmap](docs/roadmap.md), and use the issue templates before opening
+a pull request. Do not include private plans, local paths, secrets, generated
+archives, or benchmark output in public changes.
+
+## Risk Signals
+
+Inspection reports are deterministic and do not use runtime AI. Current risk
+flags include:
+
+| Flag                             | Severity   | Meaning                                                                                |
+| -------------------------------- | ---------- | -------------------------------------------------------------------------------------- |
+| `path_traversal`                 | `high`     | Entry contains `..` path segments.                                                     |
+| `absolute_path`                  | `high`     | Entry uses a POSIX absolute path.                                                      |
+| `windows_drive_path`             | `high`     | Entry looks like a Windows drive path.                                                 |
+| `hidden_file`                    | `low`      | Entry basename starts with `.`.                                                        |
+| `empty_filename`                 | `medium`   | Entry cannot be mapped to a useful safe path.                                          |
+| `too_many_files`                 | `high`     | Archive exceeds the configured file-count limit.                                       |
+| `large_uncompressed_size`        | `high`     | Archive exceeds the configured uncompressed-size limit.                                |
+| `high_compression_ratio`         | `high`     | Entry expands much more than its compressed size.                                      |
+| `unsupported_compression_method` | `medium`   | Entry uses a ZIP method Pagonic does not currently support; `safe-extract` refuses it. |
+| `crc_or_structure_error`         | `critical` | ZIP structure or CRC validation failed.                                                |
+| `suspicious_extension`           | `medium`   | Entry has an executable or script-like extension.                                      |
+| `duplicate_filename`             | `high`     | The same archive filename appears more than once.                                      |
+| `normalized_path_collision`      | `high`     | Different names resolve to the same sanitized path.                                    |
+| `case_insensitive_collision`     | `high`     | Names collide on case-insensitive filesystems.                                         |
+| `unicode_normalization_collision`| `high`     | Different Unicode spellings normalize to one path.                                     |
+| `symlink_entry`                  | `high`     | ZIP metadata marks the entry as a symbolic link.                                       |
+| `encrypted_entry`                | `high`     | Entry contents cannot be validated by the current workflow.                            |
+| `nested_archive`                 | `low`      | Entry appears to contain another archive; it is not recursively inspected.             |
+| `long_filename`                  | `medium`   | Entry name exceeds the configured review length.                                       |
+| `long_archive_comment`           | `low`      | Archive comment exceeds the configured review length.                                  |
+
+`pagonic inspect --json` emits a stable alpha report with archive totals,
+overall `risk_level`, top-level `risk_flags`, `recommended_action`, and per-entry
+metadata. Entries preserve archive order and risk flags use a deterministic
+catalog order. See the [Inspection JSON Schema Contract](docs/inspection-schema.md)
+for canonical fields, compatibility aliases, ordering guarantees, and clean,
+risky, and invalid report examples. `pagonic inspect --markdown` renders the
+same inspection as a saved human-readable report.
+
+## Command Policy
+
+Use `inspect` before extraction when the archive is untrusted. For automation,
+`verify` returns exit code `0` only when the report is within `--max-risk` and
+has no validation errors. `safe-extract` applies the same inspection gate before
+writing files and supports `--dry-run`.
+
+See the [inspection policy contract](docs/inspection-policy.md) for the exact
+clean/risky/invalid decision table, defaults, unsupported-method rule, and exit
+codes.
+
+The older `extract` command remains as a compatibility command for trusted
+archives. It uses secure path handling, but it is not an inspection policy gate;
+use `safe-extract` for untrusted input. `list` and `info` are read-only display
+commands and do not replace an inspection report.
+
+## Status
+
+The current public release is `0.5.0`: an alpha-stage, test-backed release with
+security-aware ZIP inspection, explicit policy gates, a synthetic security
+regression corpus, gated safe extraction, core ZIP behavior, CLI support,
+optional GUI packaging, MIT license, and CI-ready tests.
+
+Pagonic is not intended for production-critical automation yet and is not
+positioned as a general multi-format desktop archive manager. The next work is
+evidence-driven maintenance: collect real usage signals, expand the security
+corpus when new rules are added, and revisit deferred integrations only when a
+concrete consumer justifies them.

pagonic-0.5.0/Pagonic/__init__.py

@@ -0,0 +1,62 @@
+"""Pagonic security-aware ZIP inspection and extraction toolkit."""
+
+__version__ = "0.5.0"
+__author__ = "Pagonic contributors"
+
+from .core.formats.base import FormatHandler
+
+__all__ = [
+    "FormatHandler",
+    "ZipHandler",
+    "ZipReader",
+    "ZipWriter",
+    "inspect_archive",
+    "ArchiveEntryReport",
+    "ArchiveInspectionReport",
+    "ArchiveRisk",
+    "ArchiveInfo",
+    "CompressionStats",
+    "ExtractionFailure",
+    "ExtractionResult",
+    "FileInfo",
+    "RiskDefinition",
+    "RISK_CATALOG",
+    "get_risk_definition",
+    "__version__",
+]
+
+
+_LAZY_EXPORTS = {
+    "ZipHandler": ("Pagonic.core.formats.handlers.zip_handler", "ZipHandler"),
+    "ZipReader": ("Pagonic.core.formats.zip_reader", "ZipReader"),
+    "ZipWriter": ("Pagonic.core.formats.zip_writer", "ZipWriter"),
+    "inspect_archive": ("Pagonic.core.formats.inspection", "inspect_archive"),
+    "ArchiveEntryReport": ("Pagonic.core.formats.inspection", "ArchiveEntryReport"),
+    "ArchiveInspectionReport": (
+        "Pagonic.core.formats.inspection",
+        "ArchiveInspectionReport",
+    ),
+    "ArchiveRisk": ("Pagonic.core.formats.inspection", "ArchiveRisk"),
+    "ArchiveInfo": ("Pagonic.core.formats.results", "ArchiveInfo"),
+    "CompressionStats": ("Pagonic.core.formats.results", "CompressionStats"),
+    "ExtractionFailure": ("Pagonic.core.formats.results", "ExtractionFailure"),
+    "ExtractionResult": ("Pagonic.core.formats.results", "ExtractionResult"),
+    "FileInfo": ("Pagonic.core.formats.results", "FileInfo"),
+    "RiskDefinition": ("Pagonic.core.formats.inspection", "RiskDefinition"),
+    "RISK_CATALOG": ("Pagonic.core.formats.inspection", "RISK_CATALOG"),
+    "get_risk_definition": ("Pagonic.core.formats.inspection", "get_risk_definition"),
+}
+
+
+def __getattr__(name):
+    """Load public ZIP APIs only when a caller requests them."""
+    target = _LAZY_EXPORTS.get(name)
+    if target is None:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+    import importlib
+
+    module_name, attribute_name = target
+    value = getattr(importlib.import_module(module_name), attribute_name)
+    globals()[name] = value
+    return value

pagonic-0.5.0/Pagonic/cli/__init__.py

@@ -0,0 +1,16 @@
+"""Command-line interface for Pagonic."""
+
+from Pagonic import __version__
+
+__all__ = ["cli"]
+
+
+def __getattr__(name):
+    """Load the Click application only when the compatibility export is used."""
+    if name != "cli":
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+    from .main import cli
+
+    globals()[name] = cli
+    return cli

pagonic-0.5.0/Pagonic/cli/commands/__init__.py

@@ -0,0 +1,5 @@
+"""
+Pagonic CLI Commands Package
+============================
+Individual command implementations for the CLI.
+"""

pagonic-0.5.0/Pagonic/cli/commands/benchmark.py

@@ -0,0 +1,280 @@
+"""
+Pagonic CLI - Benchmark Command
+================================
+Local benchmark runner for Pagonic ZIP workflows.
+
+Benchmark output is intended for local validation and regression tracking, not
+as a universal performance claim.
+"""
+
+import os
+import time
+import tempfile
+import random
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich import box
+
+from Pagonic.cli.utils import format_size, format_time
+
+console = Console()
+
+
+def generate_test_data(size_mb: int) -> bytes:
+    """Generate compressible test data."""
+    # Mix of random and repetitive data (realistic compression scenario)
+    chunk_size = 1024 * 1024  # 1 MB chunks
+    data = bytearray()
+    
+    for i in range(size_mb):
+        if i % 3 == 0:
+            # Highly compressible: repeated text
+            text = "The quick brown fox jumps over the lazy dog. " * 23000
+            data.extend(text.encode('utf-8')[:chunk_size])
+        elif i % 3 == 1:
+            # Medium compressible: code-like
+            lines = []
+            for j in range(5000):
+                lines.append(f"def function_{j}(x, y): return x + y * {j}")
+            code = "\n".join(lines)
+            data.extend(code.encode('utf-8')[:chunk_size])
+        else:
+            # Low compressible: random data
+            random_bytes = bytes([random.randint(0, 255) for _ in range(chunk_size)])
+            data.extend(random_bytes)
+    
+    return bytes(data)
+
+
+def run_compression_benchmark(size_mb: int, level: int, iterations: int) -> dict:
+    """Run compression benchmark."""
+    from Pagonic.core.formats.zip_writer import ZipWriter
+    
+    results = {
+        'compress_times': [],
+        'compress_speeds': [],
+        'ratios': [],
+        'output_sizes': []
+    }
+    
+    # Generate test data once
+    console.print(f"[dim]Generating {size_mb} MB test data...[/]")
+    test_data = generate_test_data(size_mb)
+    original_size = len(test_data)
+    
+    with tempfile.TemporaryDirectory() as tmpdir:
+        # Create test file
+        test_file = Path(tmpdir) / "benchmark_data.bin"
+        test_file.write_bytes(test_data)
+        
+        for i in range(iterations):
+            output_zip = Path(tmpdir) / f"benchmark_{i}.zip"
+            
+            # Compress
+            start = time.perf_counter()
+            writer = ZipWriter(str(output_zip), compression_level=level)
+            writer.add_file(str(test_file))
+            writer.finalize()
+            end = time.perf_counter()
+            
+            compress_time = end - start
+            output_size = output_zip.stat().st_size
+            compress_speed = original_size / compress_time / 1024 / 1024  # MB/s
+            ratio = (1 - output_size / original_size) * 100
+            
+            results['compress_times'].append(compress_time)
+            results['compress_speeds'].append(compress_speed)
+            results['output_sizes'].append(output_size)
+            results['ratios'].append(ratio)
+            
+            # Cleanup
+            output_zip.unlink()
+    
+    # Calculate averages
+    results['avg_compress_time'] = sum(results['compress_times']) / len(results['compress_times'])
+    results['avg_compress_speed'] = sum(results['compress_speeds']) / len(results['compress_speeds'])
+    results['avg_ratio'] = sum(results['ratios']) / len(results['ratios'])
+    results['avg_output_size'] = sum(results['output_sizes']) / len(results['output_sizes'])
+    results['original_size'] = original_size
+    
+    return results
+
+
+def run_decompression_benchmark(size_mb: int, level: int, iterations: int) -> dict:
+    """Run decompression benchmark."""
+    from Pagonic.core.formats.zip_writer import ZipWriter
+    from Pagonic.core.formats.zip_reader import ZipReader
+    
+    results = {
+        'decompress_times': [],
+        'decompress_speeds': []
+    }
+    
+    # Generate and compress test data
+    console.print(f"[dim]Preparing compressed archive...[/]")
+    test_data = generate_test_data(size_mb)
+    original_size = len(test_data)
+    
+    with tempfile.TemporaryDirectory() as tmpdir:
+        # Create test file and archive
+        test_file = Path(tmpdir) / "benchmark_data.bin"
+        test_file.write_bytes(test_data)
+        
+        archive_path = Path(tmpdir) / "benchmark.zip"
+        writer = ZipWriter(str(archive_path), compression_level=level)
+        writer.add_file(str(test_file))
+        writer.finalize()
+        
+        # Remove original file
+        test_file.unlink()
+        
+        for i in range(iterations):
+            output_dir = Path(tmpdir) / f"output_{i}"
+            output_dir.mkdir()
+            
+            # Decompress
+            start = time.perf_counter()
+            reader = ZipReader(str(archive_path))
+            reader.extract_all(str(output_dir))
+            end = time.perf_counter()
+            
+            decompress_time = end - start
+            decompress_speed = original_size / decompress_time / 1024 / 1024  # MB/s
+            
+            results['decompress_times'].append(decompress_time)
+            results['decompress_speeds'].append(decompress_speed)
+            
+            # Cleanup
+            for f in output_dir.iterdir():
+                f.unlink()
+            output_dir.rmdir()
+    
+    # Calculate averages
+    results['avg_decompress_time'] = sum(results['decompress_times']) / len(results['decompress_times'])
+    results['avg_decompress_speed'] = sum(results['decompress_speeds']) / len(results['decompress_speeds'])
+    results['original_size'] = original_size
+    
+    return results
+
+
+@click.command()
+@click.option('--size', '-s', default=10, type=click.IntRange(1, 500), 
+              help='Test data size in MB (1-500)')
+@click.option('--level', '-l', default=6, type=click.IntRange(0, 9), 
+              help='Compression level (0-9)')
+@click.option('--iterations', '-i', default=3, type=click.IntRange(1, 10), 
+              help='Number of benchmark iterations (1-10)')
+@click.option('--compress-only', is_flag=True, help='Run only compression benchmark')
+@click.option('--decompress-only', is_flag=True, help='Run only decompression benchmark')
+def benchmark(size: int, level: int, iterations: int, compress_only: bool, decompress_only: bool):
+    """
+     Run a local benchmark.
+    
+    Measures compression and decompression on generated test data for local
+    validation and regression tracking. Results are workload-specific and are
+    not universal performance claims.
+    
+    \b
+    Examples:
+        pagonic benchmark                    # Default: 10MB, level 6, 3 iterations
+        pagonic benchmark -s 50 -l 9         # 50MB with max compression
+        pagonic benchmark -s 100 -i 5        # 100MB with 5 iterations
+        pagonic benchmark --compress-only    # Only test compression
+    """
+    console.print()
+    console.print(Panel.fit(
+        f"[bold magenta] Pagonic Local Benchmark[/]",
+        subtitle=f"Size: {size}MB | Level: {level} | Iterations: {iterations}",
+        border_style="magenta",
+        box=box.ASCII,
+    ))
+    console.print()
+    
+    try:
+        # Compression benchmark
+        if not decompress_only:
+            console.print("[bold cyan] Compression Benchmark[/]")
+            console.print("[dim]Running compression tests...[/]")
+            compress_results = run_compression_benchmark(size, level, iterations)
+            console.print("[green]Compression tests complete.[/]")
+        
+        # Decompression benchmark
+        if not compress_only:
+            console.print()
+            console.print("[bold green] Decompression Benchmark[/]")
+            console.print("[dim]Running decompression tests...[/]")
+            decompress_results = run_decompression_benchmark(size, level, iterations)
+            console.print("[green]Decompression tests complete.[/]")
+        
+        # Results table
+        console.print()
+        table = Table(title=" Benchmark Results", box=box.ASCII)
+        table.add_column("Metric", style="cyan", no_wrap=True)
+        table.add_column("Value", style="green")
+        table.add_column("Notes", style="dim")
+        
+        table.add_row(" Test Size", format_size(size * 1024 * 1024), f"{size} MB")
+        table.add_row(" Compression Level", str(level), "0=store, 9=more compression")
+        table.add_row(" Iterations", str(iterations), "")
+        table.add_row("", "", "")  # Separator
+        
+        if not decompress_only:
+            table.add_row(
+                " Compress Speed", 
+                f"[bold]{compress_results['avg_compress_speed']:.1f} MB/s[/]",
+                f"{max(compress_results['compress_speeds']) - min(compress_results['compress_speeds']):.1f}"
+            )
+            table.add_row(
+                " Compression Ratio",
+                f"{compress_results['avg_ratio']:.1f}%",
+                f"{format_size(compress_results['avg_output_size'])} output"
+            )
+            table.add_row(
+                " Compress Time",
+                format_time(compress_results['avg_compress_time']),
+                f"per {size}MB"
+            )
+        
+        if not compress_only:
+            if not decompress_only:
+                table.add_row("", "", "")  # Separator
+            table.add_row(
+                " Decompress Speed",
+                f"[bold]{decompress_results['avg_decompress_speed']:.1f} MB/s[/]",
+                f"{max(decompress_results['decompress_speeds']) - min(decompress_results['decompress_speeds']):.1f}"
+            )
+            table.add_row(
+                " Decompress Time",
+                format_time(decompress_results['avg_decompress_time']),
+                f"per {size}MB"
+            )
+        
+        console.print(table)
+        
+        # Summary panel
+        console.print()
+        console.print(Panel.fit(
+            f"[bold] Local Benchmark Notes[/]\n\n"
+            f"Compression measured [bold green]{compress_results['avg_compress_speed']:.0f} MB/s[/]; "
+            f"decompression measured [bold green]{decompress_results['avg_decompress_speed']:.0f} MB/s[/] "
+            f"for this local benchmark run.\n"
+            f"Use these numbers for local validation and regression tracking only.",
+            border_style="green",
+            box=box.ASCII,
+        ) if not compress_only and not decompress_only else None)
+        
+        console.print()
+        console.print("[bold green] Benchmark complete![/]")
+        console.print()
+        
+    except Exception as e:
+        console.print(f"\n[red] Benchmark error:[/] {str(e)}")
+        raise SystemExit(1)
+
+
+if __name__ == '__main__':
+    benchmark()