evolver-tools 12.0.0__tar.gz → 14.0.0__tar.gz

{evolver_tools-12.0.0/src/evolver_tools.egg-info → evolver_tools-14.0.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: evolver-tools
-Version: 12.0.0
-Summary: 129 CLI tools + 9 flagship projects — one pip install
+Version: 14.0.0
+Summary: 159 CLI tools + 9 flagship projects — one pip install
 Author: EVOLVER
 License-Expression: MIT
 Project-URL: Homepage, https://evolver-dev.github.io/evolver-tools

{evolver_tools-12.0.0 → evolver_tools-14.0.0}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "evolver-tools"
-version = "12.0.0"
-description = "129 CLI tools + 9 flagship projects — one pip install"
+version = "14.0.0"
+description = "159 CLI tools + 9 flagship projects — one pip install"
 readme = "README.md"
 license = "MIT"
 requires-python = ">=3.8"

{evolver_tools-12.0.0 → evolver_tools-14.0.0}/src/evolver_tools/cli.py

@@ -14,7 +14,7 @@ from evolver_tools.autoreg import auto_discover
 def list_tools():
     """Display all available tools."""
     tools = auto_discover()
-    print(f'\x1b[1;36m===== EVOLVER Tools v12.0.0 =====\x1b[0m')
+    print(f'\x1b[1;36m===== EVOLVER Tools v14.0.0 =====\x1b[0m')
     print()
     for name, info in sorted(tools.items()):
         print(f'  \033[1;33m{name:<18}\033[0m {info["desc"]}')

evolver_tools-14.0.0/src/evolver_tools/vendor/ansi_strip.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+"""ansi-strip — Strip ANSI escape codes from text."""
+import re
+import sys
+
+TOOL_META = {
+    "name": "ansi-strip",
+    "func": "main",
+    "desc": "Strip ANSI escape codes. Usage: ansi-strip [file]",
+}
+
+ANSI_PATTERN = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
+
+def main():
+    args = sys.argv[1:]
+    if args and args[0] in ("-h", "--help"):
+        print("Usage: ansi-strip [file]")
+        print("       command_with_colors | ansi-strip")
+        return
+    if args:
+        filepath = args[0]
+        try:
+            with open(filepath, "r") as f:
+                text = f.read()
+        except Exception as e:
+            print(f"Error: {e}", file=sys.stderr)
+            sys.exit(1)
+    else:
+        text = sys.stdin.read()
+    result = ANSI_PATTERN.sub("", text)
+    sys.stdout.write(result)
+
+if __name__ == "__main__":
+    main()

evolver_tools-14.0.0/src/evolver_tools/vendor/calendar_cli.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python3
+"""calendar-cli — Display a terminal calendar."""
+import calendar
+import sys
+from datetime import datetime
+
+TOOL_META = {
+    "name": "calendar-cli",
+    "func": "main",
+    "desc": "Display terminal calendar. Usage: calendar-cli [year] [month]",
+}
+
+def main():
+    args = sys.argv[1:]
+    now = datetime.now()
+    year = now.year
+    month = now.month
+    if len(args) >= 2:
+        try:
+            year = int(args[0])
+            month = int(args[1])
+        except ValueError:
+            print("Usage: calendar-cli [year] [month]", file=sys.stderr)
+            sys.exit(1)
+    elif len(args) >= 1:
+        try:
+            year = int(args[0])
+            month = None
+        except ValueError:
+            print("Usage: calendar-cli [year] [month]", file=sys.stderr)
+            sys.exit(1)
+    cal = calendar.TextCalendar()
+    if month:
+        cal_str = cal.formatmonth(year, month)
+        # Highlight today
+        if year == now.year and month == now.month:
+            today = str(now.day)
+            cal_str = cal_str.replace(f" {today} ", f"[{today}]")
+            cal_str = cal_str.replace(f"{today} ", f"[{today}]")
+        print(cal_str)
+    else:
+        print(cal.formatyear(year))
+
+if __name__ == "__main__":
+    main()

evolver_tools-14.0.0/src/evolver_tools/vendor/cert_info.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+"""cert-info — Display SSL certificate details for a domain."""
+import ssl
+import socket
+import sys
+from datetime import datetime
+
+TOOL_META = {
+    "name": "cert-info",
+    "func": "main",
+    "desc": "Show SSL certificate info for a domain. Usage: cert-info <domain> [port]",
+}
+
+def main():
+    args = sys.argv[1:]
+    if not args or args[0] in ("-h", "--help"):
+        print("Usage: cert-info <domain> [port]", file=sys.stderr)
+        print("  Default port: 443", file=sys.stderr)
+        sys.exit(1)
+    host = args[0]
+    port = int(args[1]) if len(args) > 1 else 443
+    try:
+        ctx = ssl.create_default_context()
+        with socket.create_connection((host, port), timeout=10) as sock:
+            with ctx.wrap_socket(sock, server_hostname=host) as ssock:
+                cert = ssock.getpeercert()
+        if not cert:
+            print(f"No certificate returned by {host}:{port}", file=sys.stderr)
+            sys.exit(1)
+        print(f"SSL Certificate for {host}:{port}")
+        print("=" * 50)
+        # Subject
+        subject = dict(x[0] for x in cert.get("subject", []))
+        print(f"Subject:")
+        for key, val in subject.items():
+            print(f"  {key}: {val}")
+        # Issuer
+        issuer = dict(x[0] for x in cert.get("issuer", []))
+        print(f"Issuer:")
+        for key, val in issuer.items():
+            print(f"  {key}: {val}")
+        # Validity
+        print(f"Valid from:  {cert.get('notBefore', 'N/A')}")
+        print(f"Valid until: {cert.get('notAfter', 'N/A')}")
+        # Check expiry
+        try:
+            not_after = cert.get("notAfter", "")
+            expiry = datetime.strptime(not_after, "%b %d %H:%M:%S %Y %Z")
+            now = datetime.utcnow()
+            remaining = (expiry - now).days
+            if remaining < 0:
+                print(f"⚠ EXPIRED {abs(remaining)} days ago!")
+            elif remaining < 30:
+                print(f"⚠ Expires in {remaining} days (soon!)")
+            else:
+                print(f"✓ Expires in {remaining} days")
+        except Exception:
+            pass
+        # SAN
+        san = cert.get("subjectAltName", [])
+        if san:
+            print(f"Subject Alt Names ({len(san)}):")
+            for _, name in san[:10]:
+                print(f"  {name}")
+            if len(san) > 10:
+                print(f"  ... and {len(san) - 10} more")
+        # Serial
+        serial = cert.get("serialNumber", "")
+        if serial:
+            print(f"Serial:      {serial}")
+        # Version
+        print(f"Version:     {cert.get('version', 'N/A')}")
+        # Fingerprints
+        try:
+            der = ssock.getpeercert(binary_form=True)
+            import hashlib
+            print(f"SHA256:      {hashlib.sha256(der).hexdigest()}")
+            print(f"SHA1:        {hashlib.sha1(der).hexdigest()}")
+        except Exception:
+            pass
+    except ssl.SSLError as e:
+        print(f"SSL Error: {e}", file=sys.stderr)
+        sys.exit(1)
+    except socket.gaierror:
+        print(f"Could not resolve: {host}", file=sys.stderr)
+        sys.exit(1)
+    except socket.timeout:
+        print(f"Connection timed out: {host}:{port}", file=sys.stderr)
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

evolver_tools-14.0.0/src/evolver_tools/vendor/cron_pretty.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+"""cron-pretty — Pretty-print cron expressions in human-readable format."""
+import re
+import sys
+
+TOOL_META = {
+    "name": "cron-pretty",
+    "func": "main",
+    "desc": "Describe cron schedule in plain English. Usage: cron-pretty '*/5 * * * *'",
+}
+
+WEEKDAYS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]
+MONTHS = [None, "January", "February", "March", "April", "May", "June",
+          "July", "August", "September", "October", "November", "December"]
+
+def describe(minute, hour, dom, month, dow):
+    parts = []
+    # Minute
+    if minute == "*":
+        min_desc = "every minute"
+    elif re.match(r"^\d+$", minute):
+        min_desc = f"at minute {minute}"
+    elif minute.startswith("*/"):
+        step = minute[2:]
+        min_desc = f"every {step} minutes"
+    else:
+        min_desc = f"minute {minute}"
+    parts.append(min_desc)
+    # Hour
+    if hour == "*":
+        hour_desc = "of every hour"
+    elif re.match(r"^\d+$", hour):
+        hour_desc = f"past hour {hour}"
+    elif hour.startswith("*/"):
+        step = hour[2:]
+        hour_desc = f"every {step} hours"
+    else:
+        hour_desc = f"hour {hour}"
+    parts.append(hour_desc)
+    # Day of month
+    if dom == "*":
+        dom_desc = "every day"
+    elif dom.startswith("*/"):
+        step = dom[2:]
+        dom_desc = f"every {step} days"
+    elif "," in dom:
+        days = dom.split(",")
+        dom_desc = f"on days {', '.join(days)}"
+    else:
+        dom_desc = f"on day {dom}"
+    parts.append(dom_desc)
+    # Month
+    if month == "*":
+        month_desc = "of every month"
+    elif re.match(r"^\d+$", month):
+        m = int(month)
+        month_desc = f"in {MONTHS[m] if m <= 12 else month}"
+    elif month.startswith("*/"):
+        step = month[2:]
+        month_desc = f"every {step} months"
+    else:
+        month_desc = f"in month {month}"
+    parts.append(month_desc)
+    # Day of week
+    if dow == "*":
+        dow_desc = ""
+    elif re.match(r"^\d+$", dow):
+        d = int(dow)
+        dow_desc = f"on {WEEKDAYS[d]}"
+    elif "," in dow:
+        days = [WEEKDAYS[int(d)] if d.isdigit() else d for d in dow.split(",")]
+        dow_desc = f"on {', '.join(days)}"
+    else:
+        dow_desc = f"on {dow}"
+    if dow_desc:
+        parts.append(dow_desc)
+    # Special cases
+    if minute == "0" and hour == "0" and dom == "*" and month == "*" and dow == "*":
+        return "At midnight, every day"
+    if minute == "0" and hour == "12" and dom == "*" and month == "*" and dow == "*":
+        return "At noon, every day"
+    if minute == "0" and hour in ("0", "12") and dom == "1" and month == "*" and dow == "*":
+        return f"At {hour}:00 AM, on the 1st of every month"
+    if minute == "0" and hour == "9" and dom == "*" and month == "*" and dow in ("1", "1-5"):
+        return "At 9:00 AM, Monday through Friday"
+    if minute == "30" and hour == "9" and dom == "*" and month == "*" and dow in ("1", "1-5"):
+        return "At 9:30 AM, Monday through Friday"
+    # Build description
+    result = f"{parts[0]} {parts[1]} {parts[2]} {parts[3]}"
+    if len(parts) > 4:
+        result += f" {parts[4]}"
+    return result
+
+def main():
+    args = sys.argv[1:]
+    if not args or args[0] in ("-h", "--help"):
+        print("Usage: cron-pretty '*/5 * * * *'", file=sys.stderr)
+        print("       cron-pretty '30 9 * * 1-5'", file=sys.stderr)
+        sys.exit(1)
+    expr = args[0].strip()
+    fields = expr.split()
+    # Handle special strings
+    special = {
+        "@yearly": "0 0 1 1 *",
+        "@annually": "0 0 1 1 *",
+        "@monthly": "0 0 1 * *",
+        "@weekly": "0 0 * * 0",
+        "@daily": "0 0 * * *",
+        "@hourly": "0 * * * *",
+        "@reboot": None,
+    }
+    if expr in special:
+        resolved = special[expr]
+        if resolved is None:
+            print(f"'{expr}' — runs at system startup/reboot")
+            return
+        fields = resolved.split()
+    if len(fields) != 5:
+        print(f"Invalid cron expression: '{expr}'", file=sys.stderr)
+        print("Expected format: minute hour day-of-month month day-of-week", file=sys.stderr)
+        sys.exit(1)
+    minute, hour, dom, month, dow = fields
+    description = describe(minute, hour, dom, month, dow)
+    print(f"  {expr}")
+    print(f"  → {description}")
+
+if __name__ == "__main__":
+    main()

evolver_tools-14.0.0/src/evolver_tools/vendor/disk_cleanup.py

@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+"""disk-cleanup — Analyze disk usage and suggest cleanup actions."""
+import os
+import sys
+
+TOOL_META = {
+    "name": "disk-cleanup",
+    "func": "main",
+    "desc": "Analyze disk usage and suggest cleanup. Usage: disk-cleanup [path] [--deep]",
+}
+
+COMMON_CLEANUP = [
+    ("~/.cache", "Cache files"),
+    ("~/.local/share/Trash", "Trash"),
+    ("/tmp", "Temp files"),
+    ("~/.npm/_cacache", "npm cache"),
+    ("~/.rustup/tmp", "rustup temp"),
+    ("~/.cargo/registry/cache", "Cargo cache"),
+    ("~/.gradle/caches", "Gradle cache"),
+    ("~/.m2/repository", "Maven cache"),
+    ("~/.local/share/pip/cache", "pip cache"),
+]
+
+def get_size(path):
+    try:
+        if os.path.isfile(path):
+            return os.path.getsize(path)
+        total = 0
+        for root, dirs, files in os.walk(path):
+            for f in files:
+                try:
+                    total += os.path.getsize(os.path.join(root, f))
+                except Exception:
+                    pass
+        return total
+    except Exception:
+        return 0
+
+def format_size(size):
+    for unit in ["B", "KB", "MB", "GB"]:
+        if size < 1024:
+            return f"{size:.1f} {unit}"
+        size /= 1024
+    return f"{size:.1f} TB"
+
+def find_large_files(path, limit=20, min_mb=50):
+    large = []
+    for root, dirs, files in os.walk(path):
+        dirs[:] = [d for d in dirs if not d.startswith(".") or d == "."]
+        for f in files:
+            try:
+                fp = os.path.join(root, f)
+                size = os.path.getsize(fp)
+                if size >= min_mb * 1024 * 1024:
+                    large.append((fp, size))
+            except Exception:
+                pass
+    large.sort(key=lambda x: -x[1])
+    return large[:limit]
+
+def main():
+    args = sys.argv[1:]
+    root_path = args[0] if args and not args[0].startswith("-") else os.path.expanduser("~")
+    deep = "--deep" in args
+    root_path = os.path.abspath(root_path)
+    print(f"Disk Cleanup Analysis: {root_path}")
+    print("=" * 50)
+    # Check common cleanup locations
+    print("\nCommon cleanup locations:")
+    any_found = False
+    for rel_path, label in COMMON_CLEANUP:
+        path = os.path.expanduser(rel_path)
+        if os.path.exists(path):
+            size = get_size(path)
+            if size > 0:
+                any_found = True
+                print(f"  {format_size(size):>8}  {label} ({path})")
+    if not any_found:
+        print("  (none found)")
+    # Check directory sizes if root path is a directory
+    if os.path.isdir(root_path):
+        print(f"\nLargest directories in {root_path}:")
+        dirs = []
+        for entry in os.listdir(root_path):
+            full = os.path.join(root_path, entry)
+            if os.path.isdir(full):
+                size = get_size(full)
+                dirs.append((entry, size))
+        dirs.sort(key=lambda x: -x[1])
+        for name, size in dirs[:10]:
+            if size > 1024 * 1024:  # > 1MB
+                print(f"  {format_size(size):>8}  {name}")
+    if deep:
+        print(f"\nLargest files (>50MB):")
+        large = find_large_files(root_path)
+        if large:
+            for fp, size in large:
+                rel = os.path.relpath(fp, os.path.expanduser("~"))
+                print(f"  {format_size(size):>8}  ~/{rel}")
+        else:
+            print("  (none found)")
+    print("\nSuggestions:")
+    print("  temp-cleaner --dry-run    Preview temp file cleanup")
+    print("  disk-usage                Show disk usage summary")
+
+if __name__ == "__main__":
+    main()

evolver_tools-14.0.0/src/evolver_tools/vendor/docker_helper.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+"""docker-helper — Common Docker commands helper."""
+import subprocess
+import sys
+
+TOOL_META = {
+    "name": "docker-helper",
+    "func": "main",
+    "desc": "Docker command helper. Usage: docker-helper <command> [args]",
+}
+
+COMMANDS = {
+    "ps": "docker ps",
+    "images": "docker images",
+    "stats": "docker stats --no-stream",
+    "logs": "docker logs",
+    "stop-all": "docker stop $(docker ps -q)",
+    "rm-all": "docker rm $(docker ps -aq)",
+    "rmi-none": "docker rmi $(docker images -f dangling=true -q)",
+    "prune": "docker system prune -f",
+    "prune-all": "docker system prune -af --volumes",
+    "compose-ps": "docker compose ps",
+    "top": "docker top",
+    "inspect": "docker inspect",
+    "network-ls": "docker network ls",
+    "volume-ls": "docker volume ls",
+    "clean": "docker system prune -f",
+    "exec": "docker exec -it",
+    "build": "docker build",
+    "pull": "docker pull",
+    "push": "docker push",
+    "info": "docker info",
+}
+
+def main():
+    args = sys.argv[1:]
+    if not args or args[0] in ("-h", "--help"):
+        print("Usage: docker-helper <command> [extra args...]")
+        print("\nAvailable commands:")
+        for cmd, desc in sorted(COMMANDS.items()):
+            print(f"  {cmd:<15} {desc}")
+        print()
+        print("Examples:")
+        print("  docker-helper ps")
+        print("  docker-helper logs mycontainer")
+        print("  docker-helper stop-all")
+        return
+    cmd = args[0]
+    if cmd not in COMMANDS:
+        print(f"Unknown command: {cmd}", file=sys.stderr)
+        print("Available: " + ", ".join(sorted(COMMANDS.keys())), file=sys.stderr)
+        sys.exit(1)
+    docker_cmd = COMMANDS[cmd]
+    extra = args[1:]
+    full_cmd = docker_cmd + " " + " ".join(extra) if extra else docker_cmd
+    # Handle docker exec -it specially (needs pty, just show the command)
+    if cmd == "exec":
+        print(f"Run: {full_cmd}")
+        print("Note: Use 'docker exec -it' directly for interactive sessions")
+        return
+    print(f"$ {full_cmd}")
+    try:
+        result = subprocess.run(full_cmd, shell=True, capture_output=False, timeout=60)
+        if result.returncode != 0:
+            sys.exit(result.returncode)
+    except subprocess.TimeoutExpired:
+        print("Command timed out", file=sys.stderr)
+        sys.exit(1)
+    except FileNotFoundError:
+        print("Docker not found. Is Docker installed?", file=sys.stderr)
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

evolver_tools-14.0.0/src/evolver_tools/vendor/env_diff.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+"""env-diff — Compare two .env files."""
+import os
+import sys
+
+TOOL_META = {
+    "name": "env-diff",
+    "func": "main",
+    "desc": "Compare .env files. Usage: env-diff <file1.env> <file2.env>",
+}
+
+def parse_env(filepath):
+    vars = {}
+    with open(filepath) as f:
+        for line in f:
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+            if "=" in line:
+                key, val = line.split("=", 1)
+                vars[key.strip()] = val.strip().strip("\"'")
+    return vars
+
+def main():
+    args = sys.argv[1:]
+    if len(args) < 2 or args[0] in ("-h", "--help"):
+        print("Usage: env-diff <file1.env> <file2.env>")
+        return
+    f1, f2 = args[0], args[1]
+    for f in [f1, f2]:
+        if not os.path.exists(f):
+            print(f"File not found: {f}", file=sys.stderr)
+            sys.exit(1)
+    env1 = parse_env(f1)
+    env2 = parse_env(f2)
+    keys1 = set(env1.keys())
+    keys2 = set(env2.keys())
+    only_in_1 = keys1 - keys2
+    only_in_2 = keys2 - keys1
+    common = keys1 & keys2
+    different = {k for k in common if env1[k] != env2[k]}
+    print(f"Comparison: {os.path.basename(f1)} vs {os.path.basename(f2)}")
+    print(f"Total vars: {len(keys1)} → {len(keys2)}")
+    print()
+    if only_in_1:
+        print(f"Only in {os.path.basename(f1)} ({len(only_in_1)}):")
+        for k in sorted(only_in_1):
+            print(f"  + {k}={env1[k]}")
+        print()
+    if only_in_2:
+        print(f"Only in {os.path.basename(f2)} ({len(only_in_2)}):")
+        for k in sorted(only_in_2):
+            print(f"  + {k}={env2[k]}")
+        print()
+    if different:
+        print(f"Different values ({len(different)}):")
+        for k in sorted(different):
+            print(f"  * {k}")
+            print(f"    - {env1[k]}")
+            print(f"    + {env2[k]}")
+        print()
+    if not only_in_1 and not only_in_2 and not different:
+        print("✓ Files are identical")
+    else:
+        changed = len(only_in_1) + len(only_in_2) + len(different)
+        print(f"Summary: {changed} difference(s)")
+
+if __name__ == "__main__":
+    main()

evolver_tools-14.0.0/src/evolver_tools/vendor/file_joiner.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+"""file-joiner — Join split file chunks back together."""
+import os
+import re
+import sys
+
+TOOL_META = {
+    "name": "file-joiner",
+    "func": "main",
+    "desc": "Join split file chunks. Usage: file-joiner <base_name> [--output file]",
+}
+
+def main():
+    args = sys.argv[1:]
+    if not args or args[0] in ("-h", "--help"):
+        print("Usage: file-joiner <base_name> [--output file]")
+        print("  Joins files matching base_name.part*")
+        return
+    base = args[0]
+    output = None
+    if "--output" in args:
+        idx = args.index("--output")
+        if idx + 1 < len(args):
+            output = args[idx + 1]
+    # Find parts
+    base_no_ext = os.path.splitext(base)[0]
+    ext = os.path.splitext(base)[1]
+    parts = []
+    pattern = re.compile(re.escape(base_no_ext) + r"\.part(\d+)" + re.escape(ext) + "$")
+    for f in os.listdir(os.path.dirname(base) or "."):
+        m = pattern.match(f)
+        if m:
+            parts.append((int(m.group(1)), f))
+    if not parts:
+        # Try *.part* pattern
+        pattern2 = re.compile(re.escape(base) + r"\.part(\d+)$")
+        for f in os.listdir("."):
+            m = pattern2.match(f)
+            if m:
+                parts.append((int(m.group(1)), f))
+    if not parts:
+        print(f"No parts found for: {base}", file=sys.stderr)
+        sys.exit(1)
+    parts.sort(key=lambda x: x[0])
+    if not output:
+        # Auto-detect output name
+        name_only = os.path.basename(base)
+        if ext:
+            output = base
+        else:
+            # Remove .part suffix
+            first_part = parts[0][1]
+            output = re.sub(r"\.part\d+", "", first_part)
+            if not os.path.splitext(output)[1]:
+                output = base  # fallback
+    total_size = 0
+    is_binary = False
+    for _, part_path in parts:
+        try:
+            with open(part_path, "rb") as f:
+                header = f.read(1024)
+                if b"\x00" in header:
+                    is_binary = True
+                    break
+        except Exception:
+            pass
+    if is_binary:
+        with open(output, "wb") as out:
+            for _, part_path in parts:
+                with open(part_path, "rb") as pf:
+                    data = pf.read()
+                    out.write(data)
+                    total_size += len(data)
+                print(f"  + {part_path}")
+    else:
+        with open(output, "w") as out:
+            for _, part_path in parts:
+                with open(part_path, "r") as pf:
+                    data = pf.read()
+                    out.write(data)
+                    total_size += len(data.encode())
+                print(f"  + {part_path}")
+    print(f"\nJoined {len(parts)} parts → {output} ({total_size} bytes)")
+
+if __name__ == "__main__":
+    main()