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

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

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

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

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

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+"""code-stats — Code line statistics by language."""
+import os
+import sys
+
+TOOL_META = {
+    "name": "code-stats",
+    "func": "main",
+    "desc": "Count lines of code by language. Usage: code-stats [path]",
+}
+
+EXT_MAP = {
+    ".py": "Python",
+    ".js": "JavaScript",
+    ".ts": "TypeScript",
+    ".tsx": "TypeScript React",
+    ".jsx": "JavaScript React",
+    ".go": "Go",
+    ".rs": "Rust",
+    ".java": "Java",
+    ".rb": "Ruby",
+    ".php": "PHP",
+    ".c": "C",
+    ".h": "C Header",
+    ".cpp": "C++",
+    ".hpp": "C++ Header",
+    ".cs": "C#",
+    ".swift": "Swift",
+    ".kt": "Kotlin",
+    ".scala": "Scala",
+    ".sh": "Shell",
+    ".bash": "Shell",
+    ".zsh": "Shell",
+    ".fish": "Shell",
+    ".ps1": "PowerShell",
+    ".sql": "SQL",
+    ".r": "R",
+    ".m": "Objective-C",
+    ".lua": "Lua",
+    ".pl": "Perl",
+    ".pm": "Perl",
+    ".ex": "Elixir",
+    ".exs": "Elixir",
+    ".erl": "Erlang",
+    ".hs": "Haskell",
+    ".clj": "Clojure",
+    ".cljs": "ClojureScript",
+    ".dart": "Dart",
+    ".md": "Markdown",
+    ".rst": "reStructuredText",
+    ".html": "HTML",
+    ".css": "CSS",
+    ".scss": "SCSS",
+    ".sass": "Sass",
+    ".less": "Less",
+    ".json": "JSON",
+    ".yaml": "YAML",
+    ".yml": "YAML",
+    ".toml": "TOML",
+    ".xml": "XML",
+    ".tex": "LaTeX",
+    ".dockerfile": "Dockerfile",
+    ".makefile": "Makefile",
+}
+
+IGNORE_DIRS = {".git", "__pycache__", "node_modules", ".venv", "venv", ".tox", "dist", "build", ".egg-info", ".mypy_cache", ".pytest_cache", ".ruff_cache", "target", "vendor"}
+
+def count_lines(filepath):
+    try:
+        with open(filepath, "rb") as f:
+            data = f.read()
+        lines = data.count(b"\n")
+        if data and not data.endswith(b"\n"):
+            lines += 1
+        return lines
+    except Exception:
+        return 0
+
+def main():
+    args = sys.argv[1:]
+    path = args[0] if args else "."
+    path = os.path.abspath(path)
+    stats = {}
+    total_files = 0
+    total_lines = 0
+    if os.path.isfile(path):
+        ext = os.path.splitext(path)[1].lower()
+        lang = EXT_MAP.get(ext, "Unknown")
+        lines = count_lines(path)
+        stats[lang] = {"files": 1, "lines": lines}
+        total_files = 1
+        total_lines = lines
+    else:
+        for root, dirs, files in os.walk(path):
+            dirs[:] = [d for d in dirs if d not in IGNORE_DIRS and not d.startswith(".")]
+            for f in files:
+                ext = os.path.splitext(f)[1].lower()
+                lang = EXT_MAP.get(ext)
+                if not lang:
+                    # Check for extensionless files
+                    if f.lower() in ("dockerfile",):
+                        lang = "Dockerfile"
+                    elif f.lower() in ("makefile", "gnumakefile"):
+                        lang = "Makefile"
+                    else:
+                        continue
+                filepath = os.path.join(root, f)
+                lines = count_lines(filepath)
+                if lang not in stats:
+                    stats[lang] = {"files": 0, "lines": 0}
+                stats[lang]["files"] += 1
+                stats[lang]["lines"] += lines
+                total_files += 1
+                total_lines += lines
+    if not stats:
+        print(f"No code files found in {path}")
+        return
+    # Display
+    name_width = max(len(n) for n in stats.keys())
+    sorted_stats = sorted(stats.items(), key=lambda x: -x[1]["lines"])
+    print(f"{'Language':<{name_width}}  {'Files':>6}  {'Lines':>8}  {'%':>5}")
+    print("-" * (name_width + 24))
+    for lang, info in sorted_stats:
+        pct = info["lines"] / total_lines * 100 if total_lines else 0
+        print(f"{lang:<{name_width}}  {info['files']:>6}  {info['lines']:>8}  {pct:>4.1f}%")
+    print("-" * (name_width + 24))
+    print(f"{'TOTAL':<{name_width}}  {total_files:>6}  {total_lines:>8}")
+
+if __name__ == "__main__":
+    main()

evolver_tools-12.0.0/src/evolver_tools/vendor/csv2json.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+"""csv2json — Convert CSV files to JSON."""
+import csv
+import json
+import sys
+
+TOOL_META = {
+    "name": "csv2json",
+    "func": "main",
+    "desc": "Convert CSV to JSON. Usage: csv2json [file.csv] [--pretty] [--output file.json]",
+}
+
+def main():
+    args = sys.argv[1:]
+    pretty = False
+    input_file = None
+    output_file = None
+    i = 0
+    while i < len(args):
+        if args[i] == "--pretty":
+            pretty = True
+        elif args[i] == "--output" and i + 1 < len(args):
+            output_file = args[i + 1]
+            i += 1
+        elif not args[i].startswith("-"):
+            input_file = args[i]
+        i += 1
+    try:
+        if input_file:
+            with open(input_file, "r") as f:
+                reader = csv.DictReader(f)
+                data = list(reader)
+        else:
+            reader = csv.DictReader(sys.stdin)
+            data = list(reader)
+    except Exception as e:
+        print(f"Error reading CSV: {e}", file=sys.stderr)
+        sys.exit(1)
+    if not data:
+        print("[]")
+        return
+    indent = 2 if pretty else None
+    output = json.dumps(data, indent=indent, ensure_ascii=False, default=str)
+    if output_file:
+        with open(output_file, "w") as f:
+            f.write(output)
+        print(f"Written: {output_file} ({len(data)} rows)")
+    else:
+        print(output)
+
+if __name__ == "__main__":
+    main()

evolver_tools-12.0.0/src/evolver_tools/vendor/csv_validate.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+"""csv-validate — Validate CSV files for formatting issues."""
+import csv
+import os
+import sys
+
+TOOL_META = {
+    "name": "csv-validate",
+    "func": "main",
+    "desc": "Validate CSV file format. Usage: csv-validate <file.csv>",
+}
+
+def main():
+    args = sys.argv[1:]
+    if not args or args[0] in ("-h", "--help"):
+        print("Usage: csv-validate <file.csv>")
+        return
+    filepath = args[0]
+    if not os.path.exists(filepath):
+        print(f"File not found: {filepath}", file=sys.stderr)
+        sys.exit(1)
+    errors = []
+    warnings = []
+    with open(filepath, "r") as f:
+        lines = f.readlines()
+    if not lines:
+        errors.append("File is empty")
+    else:
+        # Check header
+        header = lines[0].strip()
+        header_cols = next(csv.reader([header]))
+        expected_cols = len(header_cols)
+        if len(set(header_cols)) != len(header_cols):
+            warnings.append(f"Header has duplicate column names: {header_cols}")
+        # Check each row
+        for i, line in enumerate(lines[1:], 2):
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                row = next(csv.reader([line]))
+                if len(row) != expected_cols:
+                    errors.append(f"Row {i}: expected {expected_cols} columns, got {len(row)}")
+            except csv.Error as e:
+                errors.append(f"Row {i}: CSV parse error — {e}")
+            except StopIteration:
+                errors.append(f"Row {i}: empty row after strip")
+    if not errors and not warnings:
+        print(f"✓ {filepath}: valid CSV ({len(lines) - 1} rows, {expected_cols} columns)")
+    else:
+        if errors:
+            print(f"✗ ERRORS ({len(errors)}):")
+            for e in errors:
+                print(f"  {e}")
+        if warnings:
+            print(f"⚠ WARNINGS ({len(warnings)}):")
+            for w in warnings:
+                print(f"  {w}")
+        if errors:
+            sys.exit(1)
+
+if __name__ == "__main__":
+    main()

evolver_tools-12.0.0/src/evolver_tools/vendor/dns_lookup.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+"""dns-lookup — DNS lookup tool."""
+import sys
+
+TOOL_META = {
+    "name": "dns-lookup",
+    "func": "main",
+    "desc": "DNS lookup tool. Usage: dns-lookup <domain> [--type A|AAAA|MX|TXT|NS|CNAME|SOA]",
+}
+
+RECORD_TYPES = {
+    "A": "A",
+    "AAAA": "AAAA",
+    "MX": "MX",
+    "TXT": "TXT",
+    "NS": "NS",
+    "CNAME": "CNAME",
+    "SOA": "SOA",
+    "all": None,
+}
+
+def resolve_socket(hostname, qtype="A"):
+    """Use Python's socket module for basic DNS resolution."""
+    import socket
+    try:
+        if qtype == "A":
+            result = socket.getaddrinfo(hostname, None, socket.AF_INET)
+            addresses = set()
+            for r in result:
+                addresses.add(r[4][0])
+            return list(addresses), f"A records for {hostname}"
+        elif qtype == "AAAA":
+            result = socket.getaddrinfo(hostname, None, socket.AF_INET6)
+            addresses = set()
+            for r in result:
+                addresses.add(r[4][0])
+            return list(addresses), f"AAAA records for {hostname}"
+    except socket.gaierror as e:
+        return [], f"Error: {e}"
+    return [], "No results"
+
+def resolve_dnspython(hostname, qtype=None):
+    """Use dnspython for full DNS resolution."""
+    try:
+        import dns.resolver
+        import dns.rdatatype
+    except ImportError:
+        return None
+    results = []
+    types = [qtype] if qtype and qtype != "all" else ["A", "AAAA", "MX", "TXT", "NS", "CNAME", "SOA"]
+    for t in types:
+        try:
+            answers = dns.resolver.resolve(hostname, t)
+            for rdata in answers:
+                results.append((t, str(rdata)))
+        except Exception:
+            pass
+    return results if results else None
+
+def main():
+    args = sys.argv[1:]
+    if not args or args[0] in ("-h", "--help"):
+        print("Usage: dns-lookup <domain> [--type A|AAAA|MX|TXT|NS|CNAME|SOA|all]", file=sys.stderr)
+        print("  Default: A record", file=sys.stderr)
+        sys.exit(1)
+    hostname = args[0]
+    qtype = "A"
+    if "--type" in args:
+        idx = args.index("--type")
+        if idx + 1 < len(args):
+            qtype = args[idx + 1].upper()
+    if qtype not in RECORD_TYPES:
+        print(f"Unknown record type: {qtype}", file=sys.stderr)
+        print(f"Supported: {', '.join(RECORD_TYPES.keys())}", file=sys.stderr)
+        sys.exit(1)
+    # Try dnspython first
+    dns_results = resolve_dnspython(hostname, qtype)
+    if dns_results:
+        for t, val in dns_results:
+            print(f"{t:<6} {val}")
+        return
+    # Fallback to socket
+    addresses, label = resolve_socket(hostname, qtype)
+    if addresses:
+        for addr in addresses:
+            print(f"{qtype:<6} {addr}")
+    else:
+        print(label or f"No {qtype} records found for {hostname}")
+
+if __name__ == "__main__":
+    main()

evolver_tools-12.0.0/src/evolver_tools/vendor/file_watch.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python3
+"""file-watch — Watch a file for changes in real-time."""
+import os
+import sys
+import time
+from datetime import datetime
+
+TOOL_META = {
+    "name": "file-watch",
+    "func": "main",
+    "desc": "Watch file for changes. Usage: file-watch <file> [--tail]",
+}
+
+def main():
+    args = sys.argv[1:]
+    if not args or args[0] in ("-h", "--help"):
+        print("Usage: file-watch <file> [--tail]", file=sys.stderr)
+        print("  --tail  Follow new content (like tail -f)", file=sys.stderr)
+        sys.exit(1)
+    filepath = args[0]
+    follow = "--tail" in args
+    if not os.path.exists(filepath):
+        print(f"File not found: {filepath}", file=sys.stderr)
+        sys.exit(1)
+    last_mtime = os.path.getmtime(filepath)
+    last_size = os.path.getsize(filepath)
+    if follow:
+        # Read existing content first
+        try:
+            with open(filepath, "r") as f:
+                content = f.read()
+            print(content, end="")
+        except Exception:
+            pass
+        print(f"\n[ Watching {filepath} for changes — Ctrl+C to stop ]")
+        try:
+            while True:
+                time.sleep(0.5)
+                if os.path.getmtime(filepath) != last_mtime:
+                    new_size = os.path.getsize(filepath)
+                    if new_size > last_size:
+                        with open(filepath, "r") as f:
+                            f.seek(last_size)
+                            new_data = f.read()
+                        print(new_data, end="", flush=True)
+                    else:
+                        # File was truncated or rewritten
+                        with open(filepath, "r") as f:
+                            print(f"\n--- File updated at {datetime.now().strftime('%H:%M:%S')} ---")
+                            print(f.read(), end="", flush=True)
+                    last_mtime = os.path.getmtime(filepath)
+                    last_size = new_size
+        except KeyboardInterrupt:
+            print("\n[ Stopped ]")
+    else:
+        print(f"Last modified: {datetime.fromtimestamp(last_mtime).strftime('%Y-%m-%d %H:%M:%S')}")
+        print(f"Size: {last_size} bytes")
+        print("---")
+        try:
+            with open(filepath, "r") as f:
+                print(f.read())
+        except Exception as e:
+            print(f"Error reading: {e}", file=sys.stderr)
+
+if __name__ == "__main__":
+    main()

evolver_tools-12.0.0/src/evolver_tools/vendor/http_headers.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python3
+"""http-headers — Inspect HTTP response headers."""
+import sys
+
+TOOL_META = {
+    "name": "http-headers",
+    "func": "main",
+    "desc": "Inspect HTTP response headers. Usage: http-headers <url>",
+}
+
+def main():
+    args = sys.argv[1:]
+    if not args or args[0] in ("-h", "--help"):
+        print("Usage: http-headers <url>", file=sys.stderr)
+        sys.exit(1)
+    url = args[0]
+    if not url.startswith("http"):
+        url = "https://" + url
+    try:
+        import urllib.request
+        req = urllib.request.Request(url, method="HEAD")
+        req.add_header("User-Agent", "evolver-tools/11.0")
+        with urllib.request.urlopen(req, timeout=15) as resp:
+            print(f"HTTP/1.1 {resp.status} {resp.reason}")
+            print(f"URL: {resp.url}")
+            print("--- Headers ---")
+            for key, val in resp.headers.items():
+                print(f"  {key}: {val}")
+    except Exception as e:
+        # Fallback: try GET
+        try:
+            import urllib.request
+            req = urllib.request.Request(url)
+            req.add_header("User-Agent", "evolver-tools/11.0")
+            with urllib.request.urlopen(req, timeout=15) as resp:
+                print(f"HTTP/1.1 {resp.status} {resp.reason}")
+                print(f"URL: {resp.url}")
+                print("--- Headers ---")
+                for key, val in resp.headers.items():
+                    print(f"  {key}: {val}")
+        except Exception as e2:
+            print(f"Error: {e2}", file=sys.stderr)
+            sys.exit(1)
+
+if __name__ == "__main__":
+    main()

evolver_tools-12.0.0/src/evolver_tools/vendor/json_schema_validate.py

@@ -0,0 +1,113 @@
+#!/usr/bin/env python3
+"""json-schema-validate — Validate JSON data against a JSON schema."""
+import json
+import os
+import sys
+
+TOOL_META = {
+    "name": "json-schema-validate",
+    "func": "main",
+    "desc": "Validate JSON against JSON Schema. Usage: json-schema-validate <data.json> <schema.json>",
+}
+
+def validate_fast(data, schema):
+    """Simple fast validation without jsonschema library."""
+    errors = []
+    # Check type
+    if "type" in schema:
+        type_map = {
+            "string": str, "number": (int, float), "integer": int,
+            "boolean": bool, "null": type(None),
+            "array": list, "object": dict,
+        }
+        expected_type = type_map.get(schema["type"])
+        if expected_type and not isinstance(data, expected_type):
+            errors.append(f"Expected type '{schema['type']}', got {type(data).__name__}")
+            return errors
+    # Check required properties
+    if isinstance(data, dict):
+        required = schema.get("required", [])
+        for prop in required:
+            if prop not in data:
+                errors.append(f"Missing required property: '{prop}'")
+        # Check properties
+        for key, prop_schema in schema.get("properties", {}).items():
+            if key in data:
+                sub_errors = validate_fast(data[key], prop_schema)
+                for e in sub_errors:
+                    errors.append(f"{key}: {e}")
+    # Check array items
+    if isinstance(data, list) and "items" in schema:
+        for i, item in enumerate(data):
+            sub_errors = validate_fast(item, schema["items"])
+            for e in sub_errors:
+                errors.append(f"[{i}]: {e}")
+    # Check enum
+    if "enum" in schema and data not in schema["enum"]:
+        errors.append(f"Value {data!r} not in enum: {schema['enum']}")
+    # Check min/max
+    if isinstance(data, (int, float)):
+        if "minimum" in schema and data < schema["minimum"]:
+            errors.append(f"Value {data} < minimum {schema['minimum']}")
+        if "maximum" in schema and data > schema["maximum"]:
+            errors.append(f"Value {data} > maximum {schema['maximum']}")
+    if isinstance(data, str):
+        if "minLength" in schema and len(data) < schema["minLength"]:
+            errors.append(f"String length {len(data)} < minLength {schema['minLength']}")
+        if "maxLength" in schema and len(data) > schema["maxLength"]:
+            errors.append(f"String length {len(data)} > maxLength {schema['maxLength']}")
+        if "pattern" in schema:
+            import re
+            if not re.match(schema["pattern"], data):
+                errors.append(f"String '{data}' does not match pattern '{schema['pattern']}'")
+    if isinstance(data, list):
+        if "minItems" in schema and len(data) < schema["minItems"]:
+            errors.append(f"Array length {len(data)} < minItems {schema['minItems']}")
+        if "maxItems" in schema and len(data) > schema["maxItems"]:
+            errors.append(f"Array length {len(data)} > maxItems {schema['maxItems']}")
+    return errors
+
+def main():
+    args = sys.argv[1:]
+    if len(args) < 2 or args[0] in ("-h", "--help"):
+        print("Usage: json-schema-validate <data.json> <schema.json>")
+        print("       json-schema-validate <data.json> <schema.json> --full (try jsonschema lib)")
+        return
+    data_path = args[0]
+    schema_path = args[1]
+    use_lib = "--full" in args
+    for p in [data_path, schema_path]:
+        if not os.path.exists(p):
+            print(f"File not found: {p}", file=sys.stderr)
+            sys.exit(1)
+    with open(data_path) as f:
+        data = json.load(f)
+    with open(schema_path) as f:
+        schema = json.load(f)
+    # Try jsonschema library if requested
+    if use_lib:
+        try:
+            from jsonschema import validate, ValidationError
+            try:
+                validate(data, schema)
+                print(f"✓ {data_path}: valid against {schema_path}")
+                return
+            except ValidationError as e:
+                print(f"✗ Validation error:")
+                print(f"  {e.message}")
+                print(f"  Path: {' → '.join(str(p) for p in e.absolute_path)}")
+                sys.exit(1)
+        except ImportError:
+            print("Note: Install jsonschema for full validation: pip install jsonschema", file=sys.stderr)
+    # Fallback to fast validation
+    errors = validate_fast(data, schema)
+    if not errors:
+        print(f"✓ {data_path}: valid against {schema_path} (basic validation)")
+    else:
+        print(f"✗ Validation errors ({len(errors)}):")
+        for e in errors:
+            print(f"  • {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

evolver_tools-12.0.0/src/evolver_tools/vendor/markdown_toc.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python3
+"""markdown-toc — Generate a table of contents from markdown."""
+import re
+import sys
+
+TOOL_META = {
+    "name": "markdown-toc",
+    "func": "main",
+    "desc": "Generate table of contents from Markdown. Usage: markdown-toc [file.md]",
+}
+
+def main():
+    args = sys.argv[1:]
+    if args and args[0] in ("-h", "--help"):
+        print("Usage: markdown-toc [file.md]")
+        print("       cat file.md | markdown-toc")
+        return
+    if args:
+        with open(args[0], "r") as f:
+            content = f.read()
+    else:
+        content = sys.stdin.read()
+    toc_lines = []
+    for line in content.split("\n"):
+        m = re.match(r"^(#{1,6})\s+(.+)$", line)
+        if m:
+            level = len(m.group(1))
+            title = m.group(2).strip()
+            anchor = title.lower()
+            anchor = re.sub(r"[^a-z0-9\s\-]", "", anchor)
+            anchor = re.sub(r"\s+", "-", anchor.strip())
+            indent = "  " * (level - 1)
+            toc_lines.append(f"{indent}- [{title}](#{anchor})")
+    if toc_lines:
+        print("\n".join(toc_lines))
+    else:
+        print("(no headings found)")
+
+if __name__ == "__main__":
+    main()