evolver-tools 22.0.0__tar.gz → 24.0.0__tar.gz

{evolver_tools-22.0.0/src/evolver_tools.egg-info → evolver_tools-24.0.0}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: evolver-tools
-Version: 22.0.0
-Summary: 196 CLI tools + 9 flagship projects — one pip install
+Version: 24.0.0
+Summary: 201 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-22.0.0 → evolver_tools-24.0.0}/pyproject.toml

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

{evolver_tools-22.0.0 → evolver_tools-24.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 v22.0.0 =====\x1b[0m')
+    print(f'\x1b[1;36m===== EVOLVER Tools v23.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-24.0.0/src/evolver_tools/vendor/base58.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+"""base58 — Base58 encode/decode (Bitcoin-style alphabet).
+
+Usage: base58 encode hello
+       base58 decode 3yZe7d
+       echo hello | base58 encode
+
+Base58 uses Bitcoin alphabet (123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz).
+No '0', 'O', 'I', 'l' — safe for human transcription.
+"""
+
+import sys
+
+TOOL_META = {
+    "name": "base58",
+    "func": "main",
+    "desc": "Base58 encode/decode (Bitcoin-style alphabet)",
+}
+
+ALPHABET = b'123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+BASE = 58
+
+def b58encode(data):
+    if isinstance(data, str):
+        data = data.encode()
+    n = int.from_bytes(data, 'big')
+    if n == 0:
+        return '1'
+    res = []
+    while n > 0:
+        n, r = divmod(n, BASE)
+        res.append(chr(ALPHABET[r]))
+    # Leading zeros
+    leading = 0
+    for b in data:
+        if b == 0:
+            leading += 1
+        else:
+            break
+    return '1' * leading + ''.join(reversed(res))
+
+
+def b58decode(s):
+    n = 0
+    for c in s:
+        idx = ALPHABET.find(c.encode() if isinstance(c, str) else c)
+        if idx == -1:
+            raise ValueError(f"Invalid Base58 character: {c}")
+        n = n * BASE + idx
+    # Count leading '1's
+    leading = 0
+    for c in s:
+        if c == '1':
+            leading += 1
+        else:
+            break
+    result = n.to_bytes((n.bit_length() + 7) // 8, 'big') if n > 0 else b''
+    return b'\x00' * leading + result
+
+
+def main():
+    args = sys.argv[1:]
+    if not args or args[0] in ('-h', '--help'):
+        print(__doc__)
+        return
+
+    mode = args[0]
+    if mode not in ('encode', 'decode'):
+        print("Usage: base58 encode|decode [text]", file=sys.stderr)
+        sys.exit(1)
+
+    if len(args) > 1:
+        data = ' '.join(args[1:])
+    else:
+        data = sys.stdin.read().strip()
+
+    if not data:
+        print("Error: no input", file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        if mode == 'encode':
+            result = b58encode(data.encode() if isinstance(data, str) else data)
+        else:
+            result = b58decode(data)
+            try:
+                result = result.decode('utf-8')
+            except UnicodeDecodeError:
+                result = result.hex()
+        print(result)
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)

evolver_tools-24.0.0/src/evolver_tools/vendor/file_find.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+"""file_find — Find files by name pattern with recursive search.
+
+Usage: file_find *.txt              # Find all .txt files
+       file_find config* --dir .    # In current dir
+       file_find test_*.py --max 10 # Limit results
+       file_find Dockerfile         # Exact name match
+
+Lightweight alternative to 'find' with simpler syntax.
+Uses fnmatch pattern matching. Zero dependencies.
+"""
+
+import os
+import sys
+import fnmatch
+
+TOOL_META = {
+    "name": "file_find",
+    "func": "main",
+    "desc": "Find files by name pattern with recursive search",
+}
+
+
+def main():
+    args = sys.argv[1:]
+    if not args or args[0] in ('-h', '--help'):
+        print(__doc__)
+        return
+
+    pattern = None
+    search_dir = os.getcwd()
+    max_results = 0
+    case_insensitive = False
+    type_filter = None  # 'f' or 'd'
+
+    i = 0
+    while i < len(args):
+        if args[i] == '--dir' and i + 1 < len(args):
+            search_dir = os.path.abspath(args[i + 1])
+            i += 2
+        elif args[i] == '--max' and i + 1 < len(args):
+            max_results = int(args[i + 1])
+            i += 2
+        elif args[i] == '--type' and i + 1 < len(args):
+            type_filter = args[i + 1]
+            i += 2
+        elif args[i] == '--ignore-case' or args[i] == '-i':
+            case_insensitive = True
+            i += 1
+        elif not args[i].startswith('--'):
+            pattern = args[i]
+            i += 1
+        else:
+            i += 1
+
+    if not pattern:
+        print("Error: no pattern specified", file=sys.stderr)
+        sys.exit(1)
+
+    if not os.path.isdir(search_dir):
+        print(f"Error: directory not found: {search_dir}", file=sys.stderr)
+        sys.exit(1)
+
+    count = 0
+    for root, dirs, files in os.walk(search_dir):
+        # Skip hidden dirs by default
+        dirs[:] = [d for d in dirs if not d.startswith('.')]
+
+        targets = []
+        if type_filter in (None, 'f'):
+            targets.extend(files)
+        if type_filter in (None, 'd'):
+            targets.extend(dirs)
+
+        for name in targets:
+            matched = False
+            if case_insensitive:
+                matched = fnmatch.fnmatch(name.lower(), pattern.lower())
+            else:
+                matched = fnmatch.fnmatch(name, pattern)
+
+            if matched:
+                path = os.path.join(root, name)
+                print(path)
+                count += 1
+                if max_results and count >= max_results:
+                    print(f"--- {count} results (max: {max_results}) ---")
+                    return
+
+    if count == 0:
+        print(f"No files matching '{pattern}' in {search_dir}")

evolver_tools-24.0.0/src/evolver_tools/vendor/gzip_cli.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+"""gzip-cli — Gzip/gunzip files from CLI.
+
+Usage: gzip-cli <file>          # Compress (creates .gz)
+       gzip-cli -d <file.gz>    # Decompress
+       gzip-cli -l <file.gz>    # List contents of archive
+       cat <file> | gzip-cli    # Compress stdin to stdout
+
+Zero-dependency (stdlib only — uses gzip).
+"""
+import sys
+import os
+import gzip
+
+
+def main():
+    args = sys.argv[1:]
+
+    if '-h' in args or '--help' in args:
+        print(__doc__)
+        return
+
+    decompress = '-d' in args
+    list_mode = '-l' in args
+    args = [a for a in args if not a.startswith('-') or a in (args and args[0] and args[0])]
+
+    # Actually re-parse properly
+    args = sys.argv[1:]
+    decompress = '-d' in args or '--decompress' in args
+    list_mode = '-l' in args or '--list' in args
+    args = [a for a in args if not a.startswith('-')]
+
+    # Stdin mode
+    if not args:
+        if decompress:
+            sys.stdout.buffer.write(gzip.decompress(sys.stdin.buffer.read()))
+        else:
+            sys.stdout.buffer.write(gzip.compress(sys.stdin.buffer.read()))
+        return
+
+    for filepath in args:
+        if not os.path.exists(filepath):
+            print(f'Error: File not found: {filepath}', file=sys.stderr)
+            continue
+
+        if list_mode:
+            with gzip.open(filepath, 'rb') as f:
+                content = f.read()
+            orig_name = os.path.basename(filepath)
+            if orig_name.endswith('.gz'):
+                orig_name = orig_name[:-3]
+            compressed_size = os.path.getsize(filepath)
+            print(f'{orig_name:20s}  {len(content):>8} bytes  →  {compressed_size:>8} bytes  (ratio: {compressed_size/len(content)*100:.1f}%)')
+            continue
+
+        if decompress:
+            if not filepath.endswith('.gz'):
+                print(f'Warning: {filepath} does not end in .gz, decompressing anyway', file=sys.stderr)
+            outpath = filepath[:-3] if filepath.endswith('.gz') else filepath + '.out'
+            with gzip.open(filepath, 'rb') as f_in:
+                content = f_in.read()
+            with open(outpath, 'wb') as f_out:
+                f_out.write(content)
+            print(f'{filepath} → {outpath} ({len(content)} bytes)')
+        else:
+            outpath = filepath + '.gz'
+            with open(filepath, 'rb') as f_in:
+                content = f_in.read()
+            with gzip.open(outpath, 'wb') as f_out:
+                f_out.write(content)
+            print(f'{filepath} → {outpath} ({os.path.getsize(outpath)} bytes, ratio: {os.path.getsize(outpath)/len(content)*100:.1f}%)')
+
+
+TOOL_META = {
+    "name": "gzip-cli",
+    "func": "main",
+    "desc": "Gzip/gunzip files — compress, decompress, list archive contents",
+}
+
+if __name__ == '__main__':
+    main()

evolver_tools-24.0.0/src/evolver_tools/vendor/ip_info.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+"""ip_info — Show public IP address and geolocation info.
+
+Usage: ip_info                 # Your public IP
+       ip_info 8.8.8.8        # Lookup specific IP
+       ip_info --json          # JSON output
+
+Uses ip-api.com for geolocation data.
+"""
+
+import sys
+import json
+import urllib.request
+import urllib.error
+
+TOOL_META = {
+    "name": "ip_info",
+    "func": "main",
+    "desc": "Show public IP address and geolocation info",
+}
+
+
+def main():
+    args = sys.argv[1:]
+    ip = None
+    json_mode = False
+
+    for arg in args:
+        if arg in ('-h', '--help'):
+            print(__doc__)
+            return
+        elif arg == '--json' or arg == '-j':
+            json_mode = True
+        elif not arg.startswith('--'):
+            ip = arg
+        else:
+            print(f"Unknown flag: {arg}", file=sys.stderr)
+            sys.exit(1)
+
+    target = ip or ''
+    url = f"http://ip-api.com/json/{target}?fields=status,message,query,country,regionName,city,zip,lat,lon,isp,org,as,timezone"
+
+    try:
+        resp = urllib.request.urlopen(url, timeout=10)
+        data = json.loads(resp.read().decode())
+    except urllib.error.URLError as e:
+        print(f"Error: {e.reason}", file=sys.stderr)
+        sys.exit(1)
+    except json.JSONDecodeError:
+        print("Error: invalid response from API", file=sys.stderr)
+        sys.exit(1)
+
+    if data.get('status') == 'fail':
+        print(f"Error: {data.get('message', 'unknown')}", file=sys.stderr)
+        sys.exit(1)
+
+    if json_mode:
+        print(json.dumps(data, indent=2))
+        return
+
+    print(f"  IP:        {data['query']}")
+    print(f"  Country:   {data.get('country', 'N/A')}")
+    print(f"  Region:    {data.get('regionName', 'N/A')}")
+    print(f"  City:      {data.get('city', 'N/A')}")
+    print(f"  ZIP:       {data.get('zip', 'N/A')}")
+    print(f"  Lat/Lon:   {data.get('lat', '')}, {data.get('lon', '')}")
+    print(f"  ISP:       {data.get('isp', 'N/A')}")
+    print(f"  Org:       {data.get('org', 'N/A')}")
+    print(f"  AS:        {data.get('as', 'N/A')}")
+    print(f"  Timezone:  {data.get('timezone', 'N/A')}")

evolver_tools-24.0.0/src/evolver_tools/vendor/json_diff.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+"""json-diff — Deep diff two JSON files, show paths that differ.
+
+Usage: json-diff <file1> <file2>
+       json-diff -- <json1> <json2>
+
+Zero-dependency (stdlib only).
+"""
+import sys
+import json
+
+
+def deep_diff(a, b, path=''):
+    """Recursively compare two values and yield differing paths."""
+    if type(a) != type(b):
+        yield f'{path}: type mismatch ({type(a).__name__} vs {type(b).__name__})'
+        yield f'  - {json.dumps(a, ensure_ascii=False)[:200]}'
+        yield f'  + {json.dumps(b, ensure_ascii=False)[:200]}'
+        return
+
+    if isinstance(a, dict):
+        all_keys = set(a) | set(b)
+        for k in sorted(all_keys):
+            new_path = f'{path}.{k}' if path else k
+            if k not in a:
+                yield f'{new_path}: added'
+                yield f'  + {json.dumps(b[k], ensure_ascii=False)[:200]}'
+            elif k not in b:
+                yield f'{new_path}: removed'
+                yield f'  - {json.dumps(a[k], ensure_ascii=False)[:200]}'
+            else:
+                yield from deep_diff(a[k], b[k], new_path)
+    elif isinstance(a, list):
+        max_len = max(len(a), len(b))
+        for i in range(max_len):
+            new_path = f'{path}[{i}]'
+            if i >= len(a):
+                yield f'{new_path}: added'
+                yield f'  + {json.dumps(b[i], ensure_ascii=False)[:200]}'
+            elif i >= len(b):
+                yield f'{new_path}: removed'
+                yield f'  - {json.dumps(a[i], ensure_ascii=False)[:200]}'
+            else:
+                yield from deep_diff(a[i], b[i], new_path)
+    else:
+        if a != b:
+            yield f'{path}: changed'
+            yield f'  - {json.dumps(a, ensure_ascii=False)[:200]}'
+            yield f'  + {json.dumps(b, ensure_ascii=False)[:200]}'
+
+
+def main():
+    args = sys.argv[1:]
+
+    if '-h' in args or '--help' in args or len(args) != 2:
+        print(__doc__)
+        return
+
+    try:
+        if args[0] == '--':
+            data1 = json.loads(args[1])
+        else:
+            with open(args[0]) as f:
+                data1 = json.load(f)
+    except Exception as e:
+        print(f'Error reading {args[0]}: {e}', file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        if args[1] == '--':
+            data2 = json.loads(args[0])
+        else:
+            with open(args[1]) as f:
+                data2 = json.load(f)
+    except Exception as e:
+        print(f'Error reading {args[1]}: {e}', file=sys.stderr)
+        sys.exit(1)
+
+    diffs = list(deep_diff(data1, data2))
+    if diffs:
+        print(f'{len(diffs) // 2} difference(s) found:')
+        print()
+        for line in diffs:
+            print(line)
+    else:
+        print('No differences — files are identical.')
+
+
+TOOL_META = {
+    "name": "json-diff",
+    "func": "main",
+    "desc": "Deep diff two JSON files, show paths that differ",
+}
+
+if __name__ == '__main__':
+    main()

evolver_tools-24.0.0/src/evolver_tools/vendor/json_merge.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+"""json_merge — Merge multiple JSON files into one.
+
+Usage: json_merge file1.json file2.json
+       json_merge *.json --output merged.json
+       json_merge base.json override.json --strategy deep
+
+Merge strategies:
+  - shallow (default): top-level keys only. Later files override earlier.
+  - deep: recursive merge of nested dicts.
+  - array: concatenate arrays.
+"""
+
+import json
+import sys
+import os
+from copy import deepcopy
+
+TOOL_META = {
+    "name": "json_merge",
+    "func": "main",
+    "desc": "Merge multiple JSON files into one",
+}
+
+
+def deep_merge(a, b):
+    """Recursively merge b into a."""
+    result = deepcopy(a)
+    for key in b:
+        if key in result and isinstance(result[key], dict) and isinstance(b[key], dict):
+            result[key] = deep_merge(result[key], b[key])
+        else:
+            result[key] = deepcopy(b[key])
+    return result
+
+
+def array_merge(a, b):
+    """Merge arrays by concatenation."""
+    if isinstance(a, dict) and isinstance(b, dict):
+        result = deepcopy(a)
+        for key in b:
+            if key in result and isinstance(result[key], list) and isinstance(b[key], list):
+                result[key] = result[key] + b[key]
+            elif key in result and isinstance(result[key], dict) and isinstance(b[key], dict):
+                result[key] = deep_merge(result[key], b[key])
+            else:
+                result[key] = deepcopy(b[key])
+        return result
+    elif isinstance(a, list) and isinstance(b, list):
+        return a + b
+    return b
+
+
+def main():
+    args = sys.argv[1:]
+    files = []
+    strategy = 'shallow'
+    output = None
+
+    i = 0
+    while i < len(args):
+        if args[i] in ('-h', '--help'):
+            print(__doc__)
+            return
+        elif args[i] == '--strategy' and i + 1 < len(args):
+            strategy = args[i + 1].lower()
+            i += 2
+        elif args[i] == '--output' and i + 1 < len(args):
+            output = args[i + 1]
+            i += 2
+        elif not args[i].startswith('--'):
+            files.append(args[i])
+            i += 1
+        else:
+            i += 1
+
+    if len(files) < 2:
+        print("Error: need at least 2 JSON files", file=sys.stderr)
+        sys.exit(1)
+
+    data = []
+    for path in files:
+        if not os.path.exists(path):
+            print(f"Error: file not found: {path}", file=sys.stderr)
+            sys.exit(1)
+        with open(path) as f:
+            data.append(json.load(f))
+
+    result = data[0]
+    for d in data[1:]:
+        if strategy == 'deep':
+            result = deep_merge(result, d)
+        elif strategy == 'array':
+            result = array_merge(result, d)
+        else:
+            # shallow
+            result.update(d)
+
+    if output:
+        with open(output, 'w') as f:
+            json.dump(result, f, indent=2)
+        print(f"Merged {len(files)} files -> {output}")
+    else:
+        print(json.dumps(result, indent=2))

evolver_tools-24.0.0/src/evolver_tools/vendor/jwt_decode.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+"""jwt-decode — Decode JWT tokens (header + payload, no verification).
+
+Usage: jwt-decode <token>
+       echo <token> | jwt-decode
+
+Zero-dependency (stdlib only — uses base64 + json).
+"""
+import sys
+import base64
+import json
+
+
+def decode_part(data: str) -> str:
+    # Add padding
+    padding = 4 - len(data) % 4
+    if padding != 4:
+        data += '=' * padding
+    try:
+        decoded = base64.urlsafe_b64decode(data)
+        return decoded.decode('utf-8')
+    except Exception:
+        return f'[binary data: {len(data)} bytes]'
+
+
+def main():
+    args = sys.argv[1:]
+
+    if '-h' in args or '--help' in args:
+        print(__doc__)
+        return
+
+    if args:
+        token = args[0]
+    else:
+        token = sys.stdin.read().strip()
+
+    if not token:
+        print('Error: No JWT token provided', file=sys.stderr)
+        sys.exit(1)
+
+    parts = token.split('.')
+    if len(parts) != 3:
+        print('Error: Invalid JWT — expected 3 dot-separated parts', file=sys.stderr)
+        sys.exit(1)
+
+    print('=== JWT Decode (no verification) ===')
+    print()
+
+    # Header
+    header_raw = decode_part(parts[0])
+    try:
+        header = json.loads(header_raw)
+        print(f'Header: {json.dumps(header, indent=2)}')
+    except json.JSONDecodeError:
+        print(f'Header (raw): {header_raw}')
+
+    print()
+
+    # Payload
+    payload_raw = decode_part(parts[1])
+    try:
+        payload = json.loads(payload_raw)
+        print(f'Payload: {json.dumps(payload, indent=2)}')
+    except json.JSONDecodeError:
+        print(f'Payload (raw): {payload_raw}')
+
+    print()
+    print(f'Signature: {parts[2][:40]}... ({len(parts[2])} chars)')
+    print()
+    print('WARNING: Decoded only — signature NOT verified.')
+
+
+TOOL_META = {
+    "name": "jwt-decode",
+    "func": "main",
+    "desc": "Decode JWT tokens (header + payload, no verification)",
+}
+
+if __name__ == '__main__':
+    main()