evolver-tools 3.0.0__tar.gz → 5.0.0__tar.gz

{evolver_tools-3.0.0/src/evolver_tools.egg-info → evolver_tools-5.0.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: evolver-tools
-Version: 3.0.0
-Summary: 100 essential CLI tools - one pip install
+Version: 5.0.0
+Summary: 105 essential 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-3.0.0 → evolver_tools-5.0.0}/pyproject.toml

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

{evolver_tools-3.0.0 → evolver_tools-5.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 v3.0.0 =====\x1b[0m')
+    print(f'\x1b[1;36m===== EVOLVER Tools v5.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-5.0.0/src/evolver_tools/vendor/code_auditor.py

@@ -0,0 +1,9 @@
+"""code-auditor — Code analysis suite (CLI+TUI). Integrated from evolver-packages."""
+TOOL_META = {"name": "code-auditor", "desc": "Code analysis: complexity, security, style, deps — CLI+TUI", "func": "main"}
+
+try:
+    from code_auditor.cli import main
+except ImportError:
+    import sys
+    sys.path.insert(0, "/root/evolver-packages/code-auditor/src")
+    from code_auditor.cli import main

evolver_tools-5.0.0/src/evolver_tools/vendor/config_vault.py

@@ -0,0 +1,9 @@
+"""config-vault — Configuration security toolkit (CLI+TUI). Integrated from evolver-packages."""
+TOOL_META = {"name": "config-vault", "desc": "Config security: validate, encrypt, scan secrets — CLI+TUI", "func": "main"}
+
+try:
+    from config_vault.cli import main
+except ImportError:
+    import sys
+    sys.path.insert(0, "/root/evolver-packages/config-vault/src")
+    from config_vault.cli import main

evolver_tools-5.0.0/src/evolver_tools/vendor/crypto_box.py

@@ -0,0 +1,9 @@
+"""crypto-box — Security toolkit (CLI+TUI). Integrated from evolver-packages."""
+TOOL_META = {"name": "crypto-box", "desc": "Security: encrypt, hash, password, OTP, SSL — CLI+TUI", "func": "cli_main"}
+
+try:
+    from crypto_box.cli import cli_main
+except ImportError:
+    import sys
+    sys.path.insert(0, "/root/evolver-packages/crypto-box/src")
+    from crypto_box.cli import cli_main

evolver_tools-5.0.0/src/evolver_tools/vendor/crypto_price.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+"""
+Cryptocurrency price ticker using CoinGecko free API.
+
+Fetches real-time cryptocurrency prices in a specified fiat currency.
+Uses only Python stdlib (urllib, json, sys) — zero external dependencies.
+
+Usage:
+    python -m evolver_tools.vendor.crypto_price --coin bitcoin
+    python -m evolver_tools.vendor.crypto_price --coin ethereum --currency eur
+    python -m evolver_tools.vendor.crypto_price --list
+"""
+
+import argparse
+import json
+import sys
+import urllib.request
+import urllib.error
+
+TOOL_META = {
+    'name': 'crypto-price',
+    'func': 'main',
+    'desc': 'Cryptocurrency price ticker (CoinGecko)',
+}
+
+COINGECKO_SIMPLE_URL = 'https://api.coingecko.com/api/v3/simple/price'
+COINGECKO_LIST_URL = 'https://api.coingecko.com/api/v3/coins/list'
+
+
+def _api_get(url: str) -> dict:
+    """Make a GET request to the CoinGecko API and return parsed JSON."""
+    req = urllib.request.Request(url, headers={'User-Agent': 'crypto-price/1.0'})
+    try:
+        with urllib.request.urlopen(req, timeout=15) as resp:
+            return json.loads(resp.read().decode('utf-8'))
+    except urllib.error.HTTPError as e:
+        msg = e.read().decode('utf-8', errors='replace') if e.fp else ''
+        print(f'HTTP error {e.code}: {msg}', file=sys.stderr)
+        sys.exit(1)
+    except urllib.error.URLError as e:
+        print(f'Network error: {e.reason}', file=sys.stderr)
+        sys.exit(1)
+    except (json.JSONDecodeError, OSError, ValueError) as e:
+        print(f'Error parsing response: {e}', file=sys.stderr)
+        sys.exit(1)
+
+
+def list_coins() -> None:
+    """Fetch and display all available coins from CoinGecko."""
+    data = _api_get(COINGECKO_LIST_URL)
+    print(f'Total coins listed: {len(data)}\n')
+    # Show first 50 as a sample; user can filter with grep
+    for coin in data[:50]:
+        print(f'{coin["id"]:40s}  {coin["symbol"]:10s}  {coin["name"]}')
+    if len(data) > 50:
+        print(f'\n... and {len(data) - 50} more. Pipe through grep or use --coin <id>.')
+
+
+def get_price(coin: str, currency: str) -> None:
+    """Fetch and display the price for a single coin."""
+    url = f'{COINGECKO_SIMPLE_URL}?ids={coin}&vs_currencies={currency}'
+    data = _api_get(url)
+    if coin not in data:
+        print(
+            f'Coin "{coin}" not found. Use --list to see available coins.',
+            file=sys.stderr,
+        )
+        sys.exit(1)
+    if currency not in data[coin]:
+        print(
+            f'Currency "{currency}" not available for {coin}.',
+            file=sys.stderr,
+        )
+        sys.exit(1)
+    price = data[coin][currency]
+    print(f'{coin}: {price:.8f} {currency.upper()}')
+
+
+def main() -> None:
+    """Parse arguments and run the appropriate action."""
+    parser = argparse.ArgumentParser(
+        description='Cryptocurrency price ticker (CoinGecko)',
+    )
+    parser.add_argument(
+        '--coin',
+        default='bitcoin',
+        help='Coin ID to look up (default: bitcoin)',
+    )
+    parser.add_argument(
+        '--currency',
+        default='usd',
+        help='Fiat currency symbol (default: usd)',
+    )
+    parser.add_argument(
+        '--list',
+        action='store_true',
+        help='List all available coins and exit',
+    )
+    args = parser.parse_args()
+
+    if args.list:
+        list_coins()
+    else:
+        get_price(args.coin, args.currency)
+
+
+if __name__ == '__main__':
+    main()

evolver_tools-5.0.0/src/evolver_tools/vendor/db_mate.py

@@ -0,0 +1,9 @@
+"""db-mate — Database manager (CLI+TUI). Integrated from evolver-packages."""
+TOOL_META = {"name": "db-mate", "desc": "Database management: SQLite browser, schema, queries — CLI+TUI", "func": "entry"}
+
+try:
+    from db_mate.cli import entry
+except ImportError:
+    import sys
+    sys.path.insert(0, "/root/evolver-packages/db-mate/src")
+    from db_mate.cli import entry

evolver_tools-5.0.0/src/evolver_tools/vendor/dev_dashboard.py

@@ -0,0 +1,9 @@
+"""dev-dashboard — Developer dashboard (CLI+TUI). Integrated from evolver-packages."""
+TOOL_META = {"name": "dev-dashboard", "desc": "Developer dashboard: git, system, ports, processes — CLI+TUI", "func": "main"}
+
+try:
+    from dev_dashboard.cli import main
+except ImportError:
+    import sys
+    sys.path.insert(0, "/root/evolver-packages/dev-dashboard/src")
+    from dev_dashboard.cli import main

evolver_tools-5.0.0/src/evolver_tools/vendor/dice_roll.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+"""Zero-dependency CLI dice roller (d4, d6, d8, d10, d12, d20, d100)."""
+
+import argparse
+import random
+import sys
+
+TOOL_META = {
+    'name': 'dice-roll',
+    'func': 'main',
+    'desc': 'Dice roller (d4, d6, d8, d10, d12, d20, d100)',
+}
+
+
+def parse_dice_spec(spec: str) -> tuple[int, int]:
+    """Parse a dice spec like '2d6' into (count, sides).
+
+    Raises ValueError on invalid format or unsupported die type.
+    """
+    if 'd' not in spec:
+        raise ValueError(f"Invalid dice spec '{spec}': missing 'd' (e.g. 2d6)")
+
+    parts = spec.split('d', maxsplit=1)
+    count_str, sides_str = parts
+
+    if not sides_str:
+        raise ValueError(f"Invalid dice spec '{spec}': no sides after 'd'")
+
+    count = int(count_str) if count_str else 1
+    sides = int(sides_str)
+
+    valid_sides = {4, 6, 8, 10, 12, 20, 100}
+    if sides not in valid_sides:
+        raise ValueError(
+            f"Unsupported die type d{sides}. Supported: d4, d6, d8, d10, d12, d20, d100"
+        )
+
+    if count < 1:
+        raise ValueError(f"Number of dice must be at least 1, got {count}")
+
+    return count, sides
+
+
+def roll_dice(count: int, sides: int) -> list[int]:
+    """Roll `count` dice with `sides` sides, returning a list of results."""
+    return [random.randint(1, sides) for _ in range(count)]
+
+
+def format_results(results: list[int], sides: int) -> str:
+    """Format a roll result as a human-readable string."""
+    total = sum(results)
+    parts = ', '.join(str(r) for r in results)
+    label = f"d{sides}"
+    return f"{label}: [{parts}] = {total}"
+
+
+def main(argv: list[str] | None = None) -> int:
+    """CLI entry point. Parse args, roll dice, print results."""
+    parser = argparse.ArgumentParser(
+        description='Dice roller — roll any supported die type.',
+    )
+    parser.add_argument(
+        '--dice',
+        type=str,
+        default='1d6',
+        help='Dice to roll, e.g. 2d6, 1d20, 3d10 (default: 1d6)',
+    )
+    parser.add_argument(
+        '--rolls',
+        type=int,
+        default=1,
+        help='Number of times to roll (default: 1)',
+    )
+
+    args = parser.parse_args(argv)
+
+    if args.rolls < 1:
+        print(f"error: --rolls must be at least 1, got {args.rolls}", file=sys.stderr)
+        return 1
+
+    try:
+        count, sides = parse_dice_spec(args.dice)
+    except ValueError as e:
+        print(f"error: {e}", file=sys.stderr)
+        return 1
+
+    for i in range(args.rolls):
+        results = roll_dice(count, sides)
+        line = format_results(results, sides)
+        if args.rolls > 1:
+            print(f"Roll #{i + 1}:  {line}")
+        else:
+            print(line)
+
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

evolver_tools-5.0.0/src/evolver_tools/vendor/ip_location.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+"""
+GeoIP location lookup using ip-api.com (free, no API key required).
+
+Queries the public ip-api.com API to determine the geographic location
+of an IP address. Uses only Python stdlib (urllib, json, sys) —
+zero external dependencies.
+
+Usage:
+    python -m evolver_tools.vendor.ip_location
+    python -m evolver_tools.vendor.ip_location 8.8.8.8
+    python -m evolver_tools.vendor.ip_location --json 1.1.1.1
+"""
+
+import argparse
+import json
+import sys
+import urllib.error
+import urllib.request
+
+TOOL_META = {
+    'name': 'ip-location',
+    'func': 'main',
+    'desc': 'GeoIP location lookup (ip-api.com)',
+}
+
+API_BASE = 'http://ip-api.com/json/'
+
+
+def _api_get(ip: str) -> dict:
+    """Query ip-api.com for the given IP and return parsed JSON."""
+    url = API_BASE + ip
+    req = urllib.request.Request(url, headers={'User-Agent': 'ip-location/1.0'})
+    try:
+        with urllib.request.urlopen(req, timeout=15) as resp:
+            return json.loads(resp.read().decode('utf-8'))
+    except urllib.error.HTTPError as e:
+        msg = e.read().decode('utf-8', errors='replace') if e.fp else ''
+        print(f'HTTP error {e.code}: {msg}', file=sys.stderr)
+        sys.exit(1)
+    except urllib.error.URLError as e:
+        print(f'Network error: {e.reason}', file=sys.stderr)
+        sys.exit(1)
+    except (json.JSONDecodeError, OSError, ValueError) as e:
+        print(f'Error parsing response: {e}', file=sys.stderr)
+        sys.exit(1)
+
+
+def lookup(ip: str, as_json: bool = False) -> None:
+    """Look up an IP address and display the result."""
+    data = _api_get(ip)
+
+    if data.get('status') != 'success':
+        msg = data.get('message', 'unknown error')
+        print(f'Lookup failed for "{ip}": {msg}', file=sys.stderr)
+        sys.exit(1)
+
+    if as_json:
+        print(json.dumps(data, indent=2, ensure_ascii=False))
+        return
+
+    fields = {
+        'IP': data.get('query', ip),
+        'Country': data.get('country', ''),
+        'Country Code': data.get('countryCode', ''),
+        'Region': data.get('regionName', ''),
+        'Region Code': data.get('region', ''),
+        'City': data.get('city', ''),
+        'ZIP': data.get('zip', ''),
+        'Latitude': str(data.get('lat', '')),
+        'Longitude': str(data.get('lon', '')),
+        'Timezone': data.get('timezone', ''),
+        'ISP': data.get('isp', ''),
+        'Organization': data.get('org', ''),
+        'AS': data.get('as', ''),
+    }
+
+    max_key_len = max(len(k) for k in fields)
+    for key, val in fields.items():
+        if val:
+            print(f'{key:>{max_key_len + 1}}  {val}')
+
+
+def main() -> None:
+    """Parse arguments and run the lookup."""
+    parser = argparse.ArgumentParser(
+        description='GeoIP location lookup via ip-api.com',
+    )
+    parser.add_argument(
+        'ip',
+        nargs='?',
+        default='',
+        help='IP address to look up (default: auto, queries your own IP)',
+    )
+    parser.add_argument(
+        '--json',
+        action='store_true',
+        dest='as_json',
+        help='Output raw JSON response',
+    )
+    args = parser.parse_args()
+
+    ip = args.ip if args.ip else ''
+    lookup(ip, as_json=args.as_json)
+
+
+if __name__ == '__main__':
+    main()

evolver_tools-5.0.0/src/evolver_tools/vendor/log_hawk.py

@@ -0,0 +1,9 @@
+"""log-hawk — Log analysis toolkit (CLI+TUI). Integrated from evolver-packages."""
+TOOL_META = {"name": "log-hawk", "desc": "Log analysis: parse, filter, tail, stats — CLI+TUI", "func": "main"}
+
+try:
+    from log_hawk.cli import main
+except ImportError:
+    import sys
+    sys.path.insert(0, "/root/evolver-packages/log-hawk/src")
+    from log_hawk.cli import main

evolver_tools-5.0.0/src/evolver_tools/vendor/media_studio.py

@@ -0,0 +1,9 @@
+"""media-studio — Media utility toolkit (CLI+TUI). Integrated from evolver-packages."""
+TOOL_META = {"name": "media-studio", "desc": "Media utilities: QR, ASCII art, banner, Morse, figlet — CLI+TUI", "func": "main"}
+
+try:
+    from media_studio.cli import main
+except ImportError:
+    import sys
+    sys.path.insert(0, "/root/evolver-packages/media-studio/src")
+    from media_studio.cli import main

evolver_tools-5.0.0/src/evolver_tools/vendor/net_analyzer.py

@@ -0,0 +1,9 @@
+"""net-analyzer — Network analysis (CLI+TUI). Integrated from evolver-packages."""
+TOOL_META = {"name": "net-analyzer", "desc": "Network analysis: ping, trace, port scan, DNS — CLI+TUI", "func": "main"}
+
+try:
+    from net_analyzer.__main__ import main
+except ImportError:
+    import sys
+    sys.path.insert(0, "/root/evolver-packages/net-analyzer/src")
+    from net_analyzer.__main__ import main

evolver_tools-5.0.0/src/evolver_tools/vendor/sysmon_pro.py

@@ -0,0 +1,9 @@
+"""sysmon-pro — System monitor (CLI+TUI). Integrated from evolver-packages."""
+TOOL_META = {"name": "sysmon-pro", "desc": "System monitor: CPU, memory, disk, processes, network — CLI+TUI", "func": "run_cli"}
+
+try:
+    from sysmon_pro.cli import run as run_cli
+except ImportError:
+    import sys
+    sys.path.insert(0, "/root/evolver-packages/sysmon-pro/src")
+    from sysmon_pro.cli import run as run_cli

evolver_tools-5.0.0/src/evolver_tools/vendor/text_stats.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+"""text-stats — File/stdin text statistics analyzer.
+
+Usage: text-stats [--file PATH]
+       cat file.txt | text-stats
+
+Analyzes text and reports: word count, character count, line count,
+sentence count, average word length, and estimated reading time.
+Zero-dependency (stdlib only).
+"""
+
+import sys
+import argparse
+
+# Average reading speed: ~238 words per minute (common benchmark)
+WPM = 238
+
+
+def count_sentences(text):
+    """Count sentences by splitting on terminal punctuation."""
+    import re
+    sentences = re.split(r'[.!?]+', text)
+    return len([s for s in sentences if s.strip()])
+
+
+def count_words(text):
+    """Count words (whitespace-delimited tokens containing letters)."""
+    words = text.split()
+    return len(words)
+
+
+def count_chars(text):
+    """Count characters including spaces, excluding newlines."""
+    return len(text)
+
+
+def average_word_length(text):
+    """Compute average word length (characters per word)."""
+    words = [w for w in text.split() if w.strip()]
+    if not words:
+        return 0.0
+    return sum(len(w) for w in words) / len(words)
+
+
+def reading_time(word_count):
+    """Estimate reading time in minutes (decimal)."""
+    return word_count / WPM
+
+
+def format_reading_time(minutes):
+    """Format reading time as human-readable string."""
+    if minutes < 1:
+        secs = round(minutes * 60)
+        return f"{secs} sec"
+    mins = int(minutes)
+    secs = round((minutes - mins) * 60)
+    if secs == 0:
+        return f"{mins} min"
+    return f"{mins} min {secs} sec"
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Text statistics analyzer — word/char/line/sentence counts, "
+                    "avg word length, reading time."
+    )
+    parser.add_argument(
+        "--file", "-f",
+        type=str,
+        help="Path to input file (reads from stdin if omitted)"
+    )
+    args = parser.parse_args()
+
+    # Read input
+    if args.file:
+        try:
+            with open(args.file, "r", encoding="utf-8") as fh:
+                text = fh.read()
+        except FileNotFoundError:
+            print(f"Error: file not found: {args.file}", file=sys.stderr)
+            sys.exit(1)
+        except IOError as e:
+            print(f"Error reading file: {e}", file=sys.stderr)
+            sys.exit(1)
+    elif not sys.stdin.isatty():
+        text = sys.stdin.read()
+    else:
+        parser.print_help()
+        sys.exit(0)
+
+    # Compute statistics
+    chars = count_chars(text)
+    words = count_words(text)
+    lines = text.count("\n")
+    if lines == 0 and text:
+        lines = 1
+    sentences = count_sentences(text)
+    avg_wlen = average_word_length(text)
+    read_mins = reading_time(words)
+    read_str = format_reading_time(read_mins)
+
+    # Output
+    print(f"Characters:       {chars}")
+    print(f"Words:            {words}")
+    print(f"Lines:            {lines}")
+    print(f"Sentences:        {sentences}")
+    print(f"Avg word length:  {avg_wlen:.2f}")
+    print(f"Reading time:     {read_str}  ({WPM} wpm)")
+
+
+# === Auto-registration metadata ===
+TOOL_META = {
+    "name": "text-stats",
+    "func": "main",
+    "desc": "Text statistics (words, chars, sentences, reading time)",
+}
+
+if __name__ == "__main__":
+    main()