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

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

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

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

{evolver_tools-24.0.0 → evolver_tools-27.0.0}/src/evolver_tools/__init__.py

@@ -1,4 +1,4 @@
 """evolver-tools: 23 CLI tools in one package."""
-__version__ = "1.0.0"
+__version__ = "27.0.0"
 
 from .autoreg import auto_discover

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

@@ -0,0 +1,296 @@
+#!/usr/bin/env python3
+"""banner — ASCII art banner generator.
+Usage:  banner [--font=block|simple|wide|big] [--width=N] <text>
+        echo text | banner [--font=...] [--width=N]
+
+Four built-in fonts:
+  block  – hash-filled block letters (#)
+  simple – star-and-line outline letters (*)
+  wide   – double-spaced block letters (wider)
+  big    – uppercase geometric letters
+
+Zero-dependency (stdlib only).
+"""
+import sys
+
+# ── Font data ──────────────────────────────────────────────────────────
+# Each font: {'A': ['row0','row1',...], ...}  (5 rows per char)
+# Unknown chars render as blank columns of matching char width.
+
+_BLOCK = {
+    'A': ['  ###  ', ' #   # ', ' ##### ', ' #   # ', ' #   # '],
+    'B': [' ####  ', ' #   # ', ' ####  ', ' #   # ', ' ####  '],
+    'C': ['  #### ', ' #     ', ' #     ', ' #     ', '  #### '],
+    'D': [' ####  ', ' #   # ', ' #   # ', ' #   # ', ' ####  '],
+    'E': [' ##### ', ' #     ', ' ####  ', ' #     ', ' ##### '],
+    'F': [' ##### ', ' #     ', ' ####  ', ' #     ', ' #     '],
+    'G': ['  #### ', ' #     ', ' #  ## ', ' #   # ', '  ###  '],
+    'H': [' #   # ', ' #   # ', ' ##### ', ' #   # ', ' #   # '],
+    'I': [' ##### ', '   #   ', '   #   ', '   #   ', ' ##### '],
+    'J': ['  #####', '    #  ', '    #  ', ' # #   ', '  ##   '],
+    'K': [' #   # ', ' #  #  ', ' ###   ', ' #  #  ', ' #   # '],
+    'L': [' #     ', ' #     ', ' #     ', ' #     ', ' ##### '],
+    'M': [' ## ## ', ' #### #', ' # # # ', ' #   # ', ' #   # '],
+    'N': [' ##  # ', ' ### # ', ' # ### ', ' #  ## ', ' #   # '],
+    'O': ['  ###  ', ' #   # ', ' #   # ', ' #   # ', '  ###  '],
+    'P': [' ####  ', ' #   # ', ' ####  ', ' #     ', ' #     '],
+    'Q': ['  ###  ', ' #   # ', ' #   # ', ' #  #  ', '  ## # '],
+    'R': [' ####  ', ' #   # ', ' ####  ', ' #  #  ', ' #   # '],
+    'S': ['  #### ', ' #     ', '  ###  ', '     # ', ' ####  '],
+    'T': [' ##### ', '   #   ', '   #   ', '   #   ', '   #   '],
+    'U': [' #   # ', ' #   # ', ' #   # ', ' #   # ', '  ###  '],
+    'V': [' #   # ', ' #   # ', ' #   # ', '  # #  ', '   #   '],
+    'W': [' #   # ', ' #   # ', ' # # # ', ' #### #', ' ## ## '],
+    'X': [' #   # ', '  # #  ', '   #   ', '  # #  ', ' #   # '],
+    'Y': [' #   # ', '  # #  ', '   #   ', '   #   ', '   #   '],
+    'Z': [' ##### ', '    #  ', '   #   ', '  #    ', ' ##### '],
+    ' ': ['      ', '      ', '      ', '      ', '      '],
+    '!': ['   #   ', '   #   ', '   #   ', '       ', '   #   '],
+    '.': ['       ', '       ', '       ', '       ', '   #   '],
+    ',': ['       ', '       ', '       ', '   #   ', '  #    '],
+    '?': ['  ###  ', '     # ', '   #   ', '       ', '   #   '],
+    '0': ['  ###  ', ' #  ## ', ' # # # ', ' ##  # ', '  ###  '],
+    '1': ['   #   ', '  ##   ', '   #   ', '   #   ', ' ##### '],
+    '2': ['  ###  ', '     # ', '  ###  ', ' #     ', ' ##### '],
+    '3': ['  ###  ', '     # ', '  ###  ', '     # ', '  ###  '],
+    '4': [' #   # ', ' #   # ', ' ##### ', '     # ', '     # '],
+    '5': [' ##### ', ' #     ', '  #### ', '     # ', ' ####  '],
+    '6': ['  #### ', ' #     ', ' ####  ', ' #   # ', '  ###  '],
+    '7': [' ##### ', '     # ', '    #  ', '   #   ', '   #   '],
+    '8': ['  ###  ', ' #   # ', '  ###  ', ' #   # ', '  ###  '],
+    '9': ['  ###  ', ' #   # ', '  #### ', '     # ', ' ####  '],
+}
+
+_SIMPLE = {
+    'A': ['  ***  ', ' *   * ', ' ***** ', ' *   * ', ' *   * '],
+    'B': [' ****  ', ' *   * ', ' ****  ', ' *   * ', ' ****  '],
+    'C': ['  **** ', ' *     ', ' *     ', ' *     ', '  **** '],
+    'D': [' ****  ', ' *   * ', ' *   * ', ' *   * ', ' ****  '],
+    'E': [' ***** ', ' *     ', ' ***   ', ' *     ', ' ***** '],
+    'F': [' ***** ', ' *     ', ' ***   ', ' *     ', ' *     '],
+    'G': ['  **** ', ' *     ', ' *  ** ', ' *   * ', '  ***  '],
+    'H': [' *   * ', ' *   * ', ' ***** ', ' *   * ', ' *   * '],
+    'I': [' ***** ', '   *   ', '   *   ', '   *   ', ' ***** '],
+    'J': ['  *****', '    *  ', '    *  ', ' * *   ', '  **   '],
+    'K': [' *   * ', ' *  *  ', ' ***   ', ' *  *  ', ' *   * '],
+    'L': [' *     ', ' *     ', ' *     ', ' *     ', ' ***** '],
+    'M': [' ** ** ', ' ***** ', ' * * * ', ' *   * ', ' *   * '],
+    'N': [' **  * ', ' *** * ', ' * *** ', ' *  ** ', ' *   * '],
+    'O': ['  ***  ', ' *   * ', ' *   * ', ' *   * ', '  ***  '],
+    'P': [' ****  ', ' *   * ', ' ****  ', ' *     ', ' *     '],
+    'Q': ['  ***  ', ' *   * ', ' * * * ', ' *  *  ', '  ** * '],
+    'R': [' ****  ', ' *   * ', ' ****  ', ' *  *  ', ' *   * '],
+    'S': ['  **** ', ' *     ', '  ***  ', '     * ', ' ****  '],
+    'T': [' ***** ', '   *   ', '   *   ', '   *   ', '   *   '],
+    'U': [' *   * ', ' *   * ', ' *   * ', ' *   * ', '  ***  '],
+    'V': [' *   * ', ' *   * ', ' *   * ', '  * *  ', '   *   '],
+    'W': [' *   * ', ' *   * ', ' * * * ', ' ***** ', ' ** ** '],
+    'X': [' *   * ', '  * *  ', '   *   ', '  * *  ', ' *   * '],
+    'Y': [' *   * ', '  * *  ', '   *   ', '   *   ', '   *   '],
+    'Z': [' ***** ', '    *  ', '   *   ', '  *    ', ' ***** '],
+    ' ': ['      ', '      ', '      ', '      ', '      '],
+    '!': ['   *   ', '   *   ', '   *   ', '       ', '   *   '],
+    '.': ['       ', '       ', '       ', '       ', '   *   '],
+    '?': ['  ***  ', '     * ', '   *   ', '       ', '   *   '],
+    '0': ['  ***  ', ' *  ** ', ' * * * ', ' **  * ', '  ***  '],
+    '1': ['   *   ', '  **   ', '   *   ', '   *   ', ' ***** '],
+    '2': ['  ***  ', '     * ', '  ***  ', ' *     ', ' ***** '],
+    '3': ['  ***  ', '     * ', '  ***  ', '     * ', '  ***  '],
+    '4': [' *   * ', ' *   * ', ' ***** ', '     * ', '     * '],
+    '5': [' ***** ', ' *     ', '  **** ', '     * ', ' ****  '],
+    '6': ['  **** ', ' *     ', ' ****  ', ' *   * ', '  ***  '],
+    '7': [' ***** ', '     * ', '    *  ', '   *   ', '   *   '],
+    '8': ['  ***  ', ' *   * ', '  ***  ', ' *   * ', '  ***  '],
+    '9': ['  ***  ', ' *   * ', '  **** ', '     * ', ' ****  '],
+}
+
+# Wide font: double-spaced block (each row repeated horizontally)
+_WIDE = {k: [r.replace(' ', '  ').replace('#', '##') for r in v]
+         for k, v in _BLOCK.items()}
+
+# Big font: uppercase geometric letters using hash
+_BIG = {
+    'A': ['  #####  ', ' ##   ## ', ' ##   ## ', ' ####### ', ' ##   ## ', ' ##   ## ', ' ##   ## '],
+    'B': [' ######  ', ' ##   ## ', ' ######  ', ' ##   ## ', ' ######  '],
+    'C': ['  ###### ', ' ##      ', ' ##      ', ' ##      ', ' ###### '],
+    'D': [' ######  ', ' ##   ## ', ' ##   ## ', ' ##   ## ', ' ######  '],
+    'E': [' ####### ', ' ##      ', ' ######  ', ' ##      ', ' ####### '],
+    'F': [' ####### ', ' ##      ', ' ######  ', ' ##      ', ' ##      '],
+    'G': ['  ###### ', ' ##      ', ' ##  ### ', ' ##   ## ', '  #####  '],
+    'H': [' ##   ## ', ' ##   ## ', ' ####### ', ' ##   ## ', ' ##   ## '],
+    'I': ['  #####  ', '   ###   ', '   ###   ', '   ###   ', '  #####  '],
+    'J': ['   ##### ', '    ##   ', '    ##   ', ' ## ##   ', '  ###    '],
+    'K': [' ##   ## ', ' ##  ##  ', ' #####   ', ' ##  ##  ', ' ##   ## '],
+    'L': [' ##      ', ' ##      ', ' ##      ', ' ##      ', ' ####### '],
+    'M': [' ### ### ', ' ###### #', ' ## # ## ', ' ##   ## ', ' ##   ## '],
+    'N': [' ###  ## ', ' ##### # ', ' ## #### ', ' ##  ### ', ' ##   ## '],
+    'O': ['  #####  ', ' ##   ## ', ' ##   ## ', ' ##   ## ', '  #####  '],
+    'P': [' ######  ', ' ##   ## ', ' ######  ', ' ##      ', ' ##      '],
+    'Q': ['  #####  ', ' ##   ## ', ' ##   ## ', ' ## ###  ', '  ### ## '],
+    'R': [' ######  ', ' ##   ## ', ' ######  ', ' ##  ##  ', ' ##   ## '],
+    'S': ['  ###### ', ' ##      ', '  #####  ', '      ## ', ' ######  '],
+    'T': [' ####### ', '   ###   ', '   ###   ', '   ###   ', '   ###   '],
+    'U': [' ##   ## ', ' ##   ## ', ' ##   ## ', ' ##   ## ', '  #####  '],
+    'V': [' ##   ## ', ' ##   ## ', ' ##   ## ', '  ## ##  ', '   ###   '],
+    'W': [' ##   ## ', ' ##   ## ', ' ## # ## ', ' ###### #', ' ### ### '],
+    'X': [' ##   ## ', '  ## ##  ', '   ###   ', '  ## ##  ', ' ##   ## '],
+    'Y': [' ##   ## ', '  ## ##  ', '   ###   ', '   ###   ', '   ###   '],
+    'Z': [' ####### ', '     ##  ', '    ##   ', '   ##    ', ' ####### '],
+    ' ': ['        ', '        ', '        ', '        ', '        '],
+    '!': ['   ##   ', '   ##   ', '   ##   ', '        ', '   ##   '],
+    '.': ['        ', '        ', '        ', '        ', '   ##   '],
+    '?': ['  ##### ', '      ##', '    ### ', '        ', '    ##  '],
+    '0': ['  ##### ', ' ##  ###', ' ## # ##', ' ###  ##', '  ##### '],
+    '1': ['   ###  ', '  ####  ', '   ###  ', '   ###  ', ' #######'],
+    '2': ['  ##### ', '      ##', '   #### ', '  ##    ', ' #######'],
+    '3': ['  ##### ', '      ##', '   #### ', '      ##', '  ##### '],
+    '4': [' ##   ##', ' ##   ##', ' ########', '      ##', '      ##'],
+    '5': [' ########', ' ##      ', '  #######', '       ##', ' ########'],
+    '6': ['   #####', '  ##     ', '  ###### ', '  ##   ##', '   ####  '],
+    '7': [' #######', '     ## ', '    ##   ', '   ##    ', '   ##    '],
+    '8': ['  ##### ', ' ##   ## ', '  ##### ', ' ##   ## ', '  ##### '],
+    '9': ['  ##### ', ' ##   ## ', '  ###### ', '     ##  ', ' #####  '],
+}
+
+FONTS = {
+    'block': _BLOCK,
+    'simple': _SIMPLE,
+    'wide': _WIDE,
+    'big': _BIG,
+}
+
+
+def get_char_width(font_name):
+    """Return the width of a single character in the given font."""
+    font = FONTS.get(font_name, _BLOCK)
+    for data in font.values():
+        if data:
+            return len(data[0])
+    return 6  # fallback
+
+
+def generate_banner(text, font_name='block'):
+    """Render text using the named font. Returns list of row strings."""
+    font = FONTS.get(font_name, _BLOCK)
+    rows = max(len(v) for v in font.values()) if font else 5
+    result = ['' for _ in range(rows)]
+    for ch in text.upper():
+        if ch in font:
+            for i, row in enumerate(font[ch]):
+                result[i] += row
+        else:
+            w = get_char_width(font_name)
+            for i in range(rows):
+                result[i] += ' ' * w
+    return result
+
+
+def wrap_banner(banner_rows, width):
+    """Wrap banner lines that exceed width into multiple blocks."""
+    if not banner_rows:
+        return banner_rows
+    line_len = len(banner_rows[0])
+    if line_len <= width:
+        return banner_rows
+    # Chunk every banner row into pieces and stack vertically
+    chunk_size = width
+    num_chunks = (line_len + chunk_size - 1) // chunk_size
+    wrapped = []
+    for ci in range(num_chunks):
+        start = ci * chunk_size
+        end = min(start + chunk_size, line_len)
+        for row in banner_rows:
+            piece = row[start:end]
+            # Padded to chunk_size for alignment
+            piece = piece.ljust(chunk_size)
+            wrapped.append(piece)
+    return wrapped
+
+
+def print_banner(text, font_name='block', width=None):
+    """Render and print a banner."""
+    if not text:
+        return
+    banner_rows = generate_banner(text, font_name)
+    if width and width > 0:
+        banner_rows = wrap_banner(banner_rows, width)
+    for row in banner_rows:
+        print(row.rstrip())
+
+
+def list_fonts():
+    """Print available fonts."""
+    print("Available fonts:")
+    for name in sorted(FONTS):
+        desc = {
+            'block': 'hash-filled block letters (#)',
+            'simple': 'star-and-line outline letters (*)',
+            'wide': 'double-spaced block letters',
+            'big': 'uppercase geometric letters (7-row)',
+        }.get(name, '')
+        print(f"  {name:<10} {desc}")
+
+
+def main():
+    args = sys.argv[1:]
+
+    # Parse --font and --width manually (stdlib only, no argparse)
+    font_name = 'block'
+    width = None
+    text_args = []
+
+    i = 0
+    while i < len(args):
+        a = args[i]
+        if a == '--font' and i + 1 < len(args):
+            font_name = args[i + 1]
+            i += 2
+        elif a.startswith('--font='):
+            font_name = a.split('=', 1)[1]
+            i += 1
+        elif a == '--width' and i + 1 < len(args):
+            try:
+                width = int(args[i + 1])
+            except ValueError:
+                pass
+            i += 2
+        elif a.startswith('--width='):
+            try:
+                width = int(a.split('=', 1)[1])
+            except ValueError:
+                pass
+            i += 1
+        elif a == '--list':
+            list_fonts()
+            return
+        elif a == '--help' or a == '-h':
+            print(__doc__.strip())
+            return
+        else:
+            text_args.append(a)
+            i += 1
+
+    # Check font name
+    if font_name not in FONTS:
+        print(f"Unknown font '{font_name}'. Use --list to see available fonts.", file=sys.stderr)
+        sys.exit(1)
+
+    # Get text: positional args or stdin
+    if text_args:
+        text = ' '.join(text_args)
+    else:
+        stdin_data = sys.stdin.read() if sys.stdin is not None else ''
+        text = stdin_data.strip()
+
+    if not text:
+        print("Usage: banner [--font=NAME] [--width=N] [--list] <text>", file=sys.stderr)
+        print("       echo text | banner [--font=NAME] [--width=N]", file=sys.stderr)
+        sys.exit(1)
+
+    print_banner(text, font_name, width)
+
+
+TOOL_META = {"name": "banner", "func": "main", "desc": "ASCII art banner generator — block, simple, wide, big fonts"}
+
+if __name__ == '__main__':
+    main()

evolver_tools-27.0.0/src/evolver_tools/vendor/code_review.py

@@ -0,0 +1,323 @@
+#!/usr/bin/env python3
+"""code-review — Basic code review helper for Python files.
+
+Usage:
+    code-review <file.py> [--lines=1-50]
+    cat file.py | code-review
+
+Checks for: line length, TODOs, missing shebang, trailing whitespace,
+missing docstrings, CRLF line endings, tabs, long functions, bare
+excepts, unused imports (flagged heuristically), and more.
+
+Output uses severity tags: [ERROR], [WARN], [INFO].
+"""
+
+import sys
+import os
+import re
+import ast
+import argparse
+
+
+# ---------------------------------------------------------------------------
+# Checks
+# ---------------------------------------------------------------------------
+
+def check_shebang(lines, path):
+    """[ERROR] Python files should start with a shebang."""
+    if path and path.endswith('.py'):
+        if not lines or not lines[0].startswith('#!'):
+            return [("[ERROR] Line 1: Missing shebang "
+                     "(e.g. #!/usr/bin/env python3)")]
+    return []
+
+
+def check_line_length(lines, max_len=100):
+    """[WARN] Lines exceeding max_len characters."""
+    issues = []
+    for i, line in enumerate(lines, 1):
+        # Skip URLs and long string literals to reduce noise
+        if len(line.rstrip('\n')) > max_len:
+            stripped = line.rstrip('\n')
+            if not re.match(r'^\s*#\s*http', stripped):
+                issues.append(
+                    f"[WARN] Line {i}: {len(stripped)} chars "
+                    f"(max {max_len})"
+                )
+    return issues
+
+
+def check_todos(lines):
+    """[INFO] Flag TODO / FIXME / XXX comments."""
+    issues = []
+    pattern = re.compile(r'(TODO|FIXME|XXX|HACK|BUG)\b', re.IGNORECASE)
+    for i, line in enumerate(lines, 1):
+        m = pattern.search(line)
+        if m:
+            issues.append(f"[INFO] Line {i}: {m.group(0)} found — "
+                          f"\"{line.strip()}\"")
+    return issues
+
+
+def check_trailing_whitespace(lines):
+    """[WARN] Trailing whitespace on lines."""
+    issues = []
+    for i, line in enumerate(lines, 1):
+        if line != line.rstrip('\n').rstrip() + '\n':
+            issues.append(f"[WARN] Line {i}: trailing whitespace")
+    return issues
+
+
+def check_crlf(lines):
+    """[WARN] Carriage-return line endings (CRLF)."""
+    for i, line in enumerate(lines, 1):
+        if '\r\n' in line:
+            return ["[WARN] Line {i}: CRLF (\\r\\n) line ending detected"]
+    return []
+
+
+def check_tabs(lines):
+    """[ERROR] Tab characters used instead of spaces."""
+    issues = []
+    for i, line in enumerate(lines, 1):
+        if '\t' in line:
+            issues.append(f"[ERROR] Line {i}: tab character used")
+    return issues
+
+
+def check_missing_docstrings(code_lines, source):
+    """[INFO] Functions, classes, and modules missing docstrings."""
+    issues = []
+    try:
+        tree = ast.parse(source)
+    except SyntaxError as e:
+        return [f"[ERROR] Syntax error: {e}"]
+
+    # Module-level docstring
+    if (not isinstance(tree.body[0], ast.Expr)
+            or not isinstance(tree.body[0].value, ast.Constant)
+            or not isinstance(tree.body[0].value.value, str)):
+        issues.append("[INFO] Module: missing module-level docstring")
+
+    for node in ast.walk(tree):
+        # Functions / methods
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            doc = ast.get_docstring(node)
+            if not doc:
+                lineno = getattr(node, 'lineno', '?')
+                issues.append(
+                    f"[INFO] Line {lineno}: "
+                    f"function '{node.name}' missing docstring"
+                )
+        # Classes
+        elif isinstance(node, ast.ClassDef):
+            doc = ast.get_docstring(node)
+            if not doc:
+                lineno = getattr(node, 'lineno', '?')
+                issues.append(
+                    f"[INFO] Line {lineno}: "
+                    f"class '{node.name}' missing docstring"
+                )
+    return issues
+
+
+def check_long_functions(code_lines, source, max_lines=50):
+    """[WARN] Functions that exceed max_lines."""
+    issues = []
+    try:
+        tree = ast.parse(source)
+    except SyntaxError:
+        return []
+    for node in ast.walk(tree):
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            end_lineno = getattr(node, 'end_lineno', node.lineno)
+            nlines = end_lineno - node.lineno + 1
+            if nlines > max_lines:
+                issues.append(
+                    f"[WARN] Line {node.lineno}: "
+                    f"function '{node.name}' is {nlines} lines "
+                    f"(recommended <= {max_lines})"
+                )
+    return issues
+
+
+def check_bare_excepts(source):
+    """[ERROR] Bare 'except:' clauses without exception type."""
+    issues = []
+    pattern = re.compile(r'^(\s*?)except\s*:')
+    for i, line in enumerate(source.splitlines(), 1):
+        if pattern.match(line):
+            issues.append(
+                f"[ERROR] Line {i}: bare except clause — "
+                f"use 'except Exception:' instead"
+            )
+    return issues
+
+
+def check_imports(source):
+    """[WARN] Wildcard imports."""
+    issues = []
+    for i, line in enumerate(source.splitlines(), 1):
+        stripped = line.strip()
+        if stripped.startswith('from ') and ' import *' in stripped:
+            issues.append(
+                f"[WARN] Line {i}: wildcard import (from ... import *)"
+            )
+    return issues
+
+
+# ---------------------------------------------------------------------------
+# Parse --lines argument
+# ---------------------------------------------------------------------------
+
+def parse_line_range(lines_arg, total_lines):
+    """Return (start, end) 1-indexed slice, or (1, total_lines)."""
+    if not lines_arg:
+        return (1, total_lines)
+    m = re.match(r'^(\d+)(?:-(\d+))?$', lines_arg)
+    if not m:
+        sys.stderr.write(f"error: invalid --lines format '{lines_arg}'. "
+                         "Use N-M (e.g. 1-50) or just N.\n")
+        sys.exit(1)
+    start = int(m.group(1))
+    end = int(m.group(2)) if m.group(2) else start
+    if start < 1:
+        start = 1
+    if end > total_lines:
+        end = total_lines
+    if start > end:
+        start, end = end, start
+    return (start, end)
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Code review helper for Python files."
+    )
+    parser.add_argument(
+        'file', nargs='?', default=None,
+        help="Path to Python file to review (reads from stdin if omitted)"
+    )
+    parser.add_argument(
+        '--lines', default=None,
+        help="Line range to check, e.g. '1-50' or '42'"
+    )
+    parser.add_argument(
+        '--max-line-length', type=int, default=100,
+        help="Maximum allowed line length (default: 100)"
+    )
+    parser.add_argument(
+        '--max-function-lines', type=int, default=50,
+        help="Maximum function length in lines (default: 50)"
+    )
+    args = parser.parse_args()
+
+    if args.file:
+        path = args.file
+        try:
+            with open(path, 'rb') as f:
+                raw = f.read()
+        except FileNotFoundError:
+            sys.stderr.write(f"error: file not found: {path}\n")
+            sys.exit(1)
+        except PermissionError:
+            sys.stderr.write(f"error: permission denied: {path}\n")
+            sys.exit(1)
+    else:
+        path = None
+        raw = sys.stdin.buffer.read()
+
+    # Decode, preserving line endings for CRLF detection
+    try:
+        text = raw.decode('utf-8')
+    except UnicodeDecodeError:
+        text = raw.decode('latin-1')
+        sys.stderr.write("warning: file is not UTF-8; decoded as latin-1\n")
+
+    all_lines = text.splitlines(keepends=True)
+    total = len(all_lines)
+
+    start, end = parse_line_range(args.lines, total)
+    if not args.lines:
+        start, end = 1, total
+
+    lines = all_lines[start - 1:end]
+    source = ''.join(lines)
+
+    # Collect all issues
+    all_issues = []
+
+    # --lines mode: only run per-line checks on the subset
+    all_issues.extend(check_shebang(all_lines, path))
+    all_issues.extend(check_line_length(lines, args.max_line_length))
+    all_issues.extend(check_todos(lines))
+    all_issues.extend(check_trailing_whitespace(lines))
+    all_issues.extend(check_crlf(lines))
+    all_issues.extend(check_tabs(lines))
+    # AST-based checks need the full function boundaries; we always run
+    # on the full file for these, but only report issues in the range.
+    full_source = ''.join(all_lines)
+    for issue in check_missing_docstrings(all_lines, full_source):
+        lineno_match = re.search(r'Line (\d+)', issue)
+        if lineno_match:
+            lineno = int(lineno_match.group(1))
+            if start <= lineno <= end:
+                all_issues.append(issue)
+        else:
+            all_issues.append(issue)
+    for issue in check_long_functions(all_lines, full_source,
+                                      args.max_function_lines):
+        lineno_match = re.search(r'Line (\d+)', issue)
+        if lineno_match:
+            lineno = int(lineno_match.group(1))
+            if start <= lineno <= end:
+                all_issues.append(issue)
+        else:
+            all_issues.append(issue)
+    all_issues.extend(check_bare_excepts(source))
+    all_issues.extend(check_imports(source))
+
+    # Sort by line number where possible
+    def sort_key(issue):
+        m = re.search(r'Line (\d+)', issue)
+        return int(m.group(1)) if m else 0
+    all_issues.sort(key=sort_key)
+
+    # Output
+    if not all_issues:
+        print("No issues found.")
+        return
+
+    for issue in all_issues:
+        print(issue)
+
+    # Summary
+    errors = sum(1 for i in all_issues if i.startswith('[ERROR]'))
+    warns = sum(1 for i in all_issues if i.startswith('[WARN]'))
+    infos = sum(1 for i in all_issues if i.startswith('[INFO]'))
+    print(f"\n--- Summary: {errors} errors, {warns} warnings, "
+          f"{infos} info items ---")
+
+    if errors:
+        sys.exit(1)
+
+
+# ---------------------------------------------------------------------------
+# Tool metadata for auto-discovery
+# ---------------------------------------------------------------------------
+
+TOOL_META = {
+    "name": "code-review",
+    "func": "main",
+    "desc": "Basic code review: line length, TODOs, shebang, "
+            "trailing whitespace, docstrings, CRLF, tabs, "
+            "long functions, bare excepts, wildcard imports"
+}
+
+
+if __name__ == '__main__':
+    main()