py2cpp.py

import ast
import sys
import subprocess
import platform
import time
from pathlib import Path
from typing import Any, List, Dict, Optional, Set, Tuple
from dataclasses import dataclass, field
from enum import Enum
import tokenize
from io import StringIO

try:
    import typer
    from typer import Typer
except ImportError:
    print("❌ Typer required: pip install typer")
    sys.exit(1)

# ═══════════════════════════════════════════════════════════════════════════
# CONFIGURATION & CONSTANTS
# ═══════════════════════════════════════════════════════════════════════════

VERSION = "0.1.1"
CPP_STANDARD = "c++20"

class OptLevel(str, Enum):
    O0 = "-O0"
    O1 = "-O1"
    O2 = "-O2"
    O3 = "-O3"
    Os = "-Os"

@dataclass
class TranspileConfig:
    input_file: Path
    output_file: Optional[Path] = None
    cpp_standard: str = "c++20"
    optimize: str = "-O3"
    run: bool = False
    keep_cpp: bool = True
    verbose: bool = False

# ═══════════════════════════════════════════════════════════════════════════
# C++ RUNTIME PREAMBLE (C++20 with Advanced Features)
# ═══════════════════════════════════════════════════════════════════════════

CPP_PREAMBLE = r"""
// ═══════════════════════════════════════════════════════════════════════════
// Generated by Py2Cpp Ultimate | C++20 Runtime Environment
// ═══════════════════════════════════════════════════════════════════════════

#include <iostream>
#include <vector>
#include <string>
#include <memory>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <algorithm>
#include <functional>
#include <sstream>
#include <cmath>
#include <thread>
#include <future>
#include <chrono>
#include <format>
#include <concepts>
#include <ranges>
#include <any>
#include <stdexcept>
#include <optional>
#include <variant>
#include <type_traits>
#include <tuple>
#include <queue>
#include <stack>
#include <numeric>
#include <random>

namespace py {
    // ─────────────────────────────────────────────────────────────────────
    // Type Aliases
    // ─────────────────────────────────────────────────────────────────────
    using str = std::string;
    template<typename T> using ptr = std::shared_ptr<T>;
    template<typename T> using list = std::vector<T>;
    template<typename K, typename V> using dict = std::map<K, V>;
    template<typename T> using set_t = std::set<T>;
    template<typename T> using opt = std::optional<T>;
    
    // ─────────────────────────────────────────────────────────────────────
    // Dynamic Type (Python Any)
    // ─────────────────────────────────────────────────────────────────────
    struct PyObject {
        std::any value;
        std::string type_name;
        
        PyObject() : type_name("NoneType") {}
        
        template<typename T>
        PyObject(const T& v) : value(v) {
            if constexpr (std::is_same_v<T, std::string>) type_name = "str";
            else if constexpr (std::is_same_v<T, int>) type_name = "int";
            else if constexpr (std::is_same_v<T, double>) type_name = "float";
            else if constexpr (std::is_same_v<T, bool>) type_name = "bool";
            else type_name = "object";
        }
    };
    
    // ─────────────────────────────────────────────────────────────────────
    // Print function (Python-like)
    // ─────────────────────────────────────────────────────────────────────
    void print() { std::cout << std::endl; }
    
    template <typename T, typename... Args>
    void print(const T& first, const Args&... args) {
        if constexpr (std::is_same_v<T, std::string>) {
            std::cout << first;
        } else if constexpr (std::is_same_v<T, const char*>) {
            std::cout << first;
        } else if constexpr (std::is_same_v<T, bool>) {
            std::cout << (first ? "True" : "False");
        } else {
            std::cout << first;
        }
        
        if constexpr (sizeof...(args) > 0) {
            std::cout << " ";
            print(args...);
        } else {
            std::cout << std::endl;
        }
    }
    
    // ─────────────────────────────────────────────────────────────────────
    // String Conversion (Type Casting)
    // ─────────────────────────────────────────────────────────────────────
    template<typename T>
    std::string str_cast(const T& t) {
        if constexpr (std::is_same_v<T, std::string>) return t;
        else if constexpr (std::is_same_v<T, bool>) return t ? "True" : "False";
        else if constexpr (std::is_same_v<T, int>) return std::to_string(t);
        else if constexpr (std::is_same_v<T, long>) return std::to_string(t);
        else if constexpr (std::is_same_v<T, double>) {
            std::ostringstream oss;
            oss << std::fixed << t;
            return oss.str();
        } else if constexpr (std::is_same_v<T, const char*>) return std::string(t);
        return "unknown";
    }
    
    // ─────────────────────────────────────────────────────────────────────
    // Range function (Python range)
    // ─────────────────────────────────────────────────────────────────────
    inline std::vector<int> range(int start, int stop = -1, int step = 1) {
        if (stop == -1) { stop = start; start = 0; }
        std::vector<int> result;
        if (step == 0) throw std::runtime_error("range() step cannot be 0");
        if (step > 0) {
            for (int i = start; i < stop; i += step) result.push_back(i);
        } else {
            for (int i = start; i > stop; i += step) result.push_back(i);
        }
        return result;
    }
    
    // ─────────────────────────────────────────────────────────────────────
    // Length function
    // ─────────────────────────────────────────────────────────────────────
    template<typename T>
    inline int len(const std::vector<T>& v) { 
        return static_cast<int>(v.size()); 
    }
    
    inline int len(const std::string& s) { 
        return static_cast<int>(s.length()); 
    }
    
    template<typename K, typename V>
    inline int len(const std::map<K, V>& m) { 
        return static_cast<int>(m.size()); 
    }
    
    template<typename T>
    inline int len(const std::set<T>& s) { 
        return static_cast<int>(s.size()); 
    }
    
    // ─────────────────────────────────────────────────────────────────────
    // Map, Filter, Zip (Higher-order functions)
    // ─────────────────────────────────────────────────────────────────────
    template<typename Func, typename Container>
    auto map_py(Func f, const Container& cont) {
        std::vector<decltype(f(*cont.begin()))> result;
        for (const auto& item : cont) {
            result.push_back(f(item));
        }
        return result;
    }
    
    template<typename Func, typename Container>
    auto filter_py(Func f, const Container& cont) {
        Container result;
        for (const auto& item : cont) {
            if (f(item)) result.push_back(item);
        }
        return result;
    }
    
    // Zip multiple containers
    template<typename T, typename U>
    std::vector<std::pair<T, U>> zip(const std::vector<T>& a, const std::vector<U>& b) {
        std::vector<std::pair<T, U>> result;
        size_t min_size = std::min(a.size(), b.size());
        for (size_t i = 0; i < min_size; ++i) {
            result.push_back({a[i], b[i]});
        }
        return result;
    }
    
    // Enumerate
    template<typename T>
    std::vector<std::pair<int, T>> enumerate(const std::vector<T>& cont) {
        std::vector<std::pair<int, T>> result;
        for (size_t i = 0; i < cont.size(); ++i) {
            result.push_back({static_cast<int>(i), cont[i]});
        }
        return result;
    }
    
    // ─────────────────────────────────────────────────────────────────────
    // Any / All (Boolean aggregates)
    // ─────────────────────────────────────────────────────────────────────
    template<typename Container>
    bool any_of(const Container& cont) {
        return std::any_of(cont.begin(), cont.end(), [](const auto& x) { 
            return static_cast<bool>(x); 
        });
    }
    
    template<typename Container>
    bool all_of(const Container& cont) {
        return std::all_of(cont.begin(), cont.end(), [](const auto& x) { 
            return static_cast<bool>(x); 
        });
    }
    
    // ─────────────────────────────────────────────────────────────────────
    // Sum (reduce with addition)
    // ─────────────────────────────────────────────────────────────────────
    template<typename Container>
    auto sum_py(const Container& cont, typename Container::value_type init = 0) {
        return std::accumulate(cont.begin(), cont.end(), init);
    }
    
    // ─────────────────────────────────────────────────────────────────────
    // Input function
    // ─────────────────────────────────────────────────────────────────────
    inline std::string input(const std::string& prompt = "") {
        if (!prompt.empty()) std::cout << prompt << std::flush;
        std::string line;
        std::getline(std::cin, line);
        return line;
    }
    
    // ─────────────────────────────────────────────────────────────────────
    // Type checking
    // ─────────────────────────────────────────────────────────────────────
    template<typename T, typename U>
    bool isinstance(const U& obj) {
        return std::is_same_v<T, U>;
    }
    
    // ─────────────────────────────────────────────────────────────────────
    // Min / Max
    // ─────────────────────────────────────────────────────────────────────
    template<typename Container>
    auto min_py(const Container& cont) {
        return *std::min_element(cont.begin(), cont.end());
    }
    
    template<typename Container>
    auto max_py(const Container& cont) {
        return *std::max_element(cont.begin(), cont.end());
    }
    
    // ─────────────────────────────────────────────────────────────────────
    // Sorted
    // ─────────────────────────────────────────────────────────────────────
    template<typename Container>
    Container sorted_py(Container cont) {
        std::sort(cont.begin(), cont.end());
        return cont;
    }
    
    template<typename Container, typename Comp>
    Container sorted_py(Container cont, Comp cmp) {
        std::sort(cont.begin(), cont.end(), cmp);
        return cont;
    }
    
    // ─────────────────────────────────────────────────────────────────────
    // Reversed
    // ─────────────────────────────────────────────────────────────────────
    template<typename Container>
    Container reversed_py(Container cont) {
        std::reverse(cont.begin(), cont.end());
        return cont;
    }
    
    // ─────────────────────────────────────────────────────────────────────
    // Int / Float / Bool / Str conversions
    // ─────────────────────────────────────────────────────────────────────
    template<typename T>
    int int_cast(const T& val) {
        if constexpr (std::is_same_v<T, std::string>) {
            return std::stoi(val);
        } else if constexpr (std::is_same_v<T, double>) {
            return static_cast<int>(val);
        } else {
            return static_cast<int>(val);
        }
    }
    
    template<typename T>
    double float_cast(const T& val) {
        if constexpr (std::is_same_v<T, std::string>) {
            return std::stod(val);
        } else {
            return static_cast<double>(val);
        }
    }
    
    template<typename T>
    bool bool_cast(const T& val) {
        if constexpr (std::is_same_v<T, int>) return val != 0;
        else if constexpr (std::is_same_v<T, double>) return val != 0.0;
        else if constexpr (std::is_same_v<T, std::string>) return !val.empty();
        else return static_cast<bool>(val);
    }
}

using namespace py;
"""

def extract_comments(source: str) -> Dict[int, List[str]]:
    """Extract Python comments with their line numbers."""
    comments: Dict[int, List[str]] = {}
    try:
        tokens = tokenize.generate_tokens(StringIO(source).readline)
        for tok in tokens:
            if tok.type == tokenize.COMMENT:
                line = tok.start[0]
                text = tok.string[1:].strip()
                comments.setdefault(line, []).append(text)
    except tokenize.TokenError:
        pass
    return comments

# ═══════════════════════════════════════════════════════════════════════════
# LOGGER
# ═══════════════════════════════════════════════════════════════════════════

class Logger:
    """Comprehensive logging with timing and statistics."""
    
    def __init__(self, verbose: bool = False):
        self.verbose = verbose
        self.start_time = time.time()
        self.stats = {
            "nodes": 0,
            "errors": 0,
            "warnings": 0,
            "functions": 0,
            "classes": 0,
            "comprehensions": 0
        }
    
    def info(self, msg: str) -> None:
        if self.verbose:
            typer.secho(f"ℹ️  {msg}", fg=typer.colors.BLUE)
    
    def success(self, msg: str) -> None:
        typer.secho(f"✅ {msg}", fg=typer.colors.GREEN)
    
    def warn(self, msg: str) -> None:
        typer.secho(f"⚠️  {msg}", fg=typer.colors.YELLOW)
        self.stats["warnings"] += 1
    
    def error(self, msg: str) -> None:
        typer.secho(f"❌ {msg}", fg=typer.colors.RED)
        self.stats["errors"] += 1
    
    def debug(self, msg: str) -> None:
        if self.verbose:
            typer.secho(f"🔧 {msg}", fg=typer.colors.CYAN)
    
    def report(self) -> Dict[str, Any]:
        duration = time.time() - self.start_time
        return {
            "duration": f"{duration:.2f}s",
            "nodes_processed": self.stats["nodes"],
            "functions": self.stats["functions"],
            "classes": self.stats["classes"],
            "comprehensions": self.stats["comprehensions"],
            "warnings": self.stats["warnings"],
            "errors": self.stats["errors"],
            "status": "SUCCESS" if self.stats["errors"] == 0 else "FAILED"
        }

# ═══════════════════════════════════════════════════════════════════════════
# ADVANCED TYPE INFERENCE ENGINE
# ═══════════════════════════════════════════════════════════════════════════

class TypeInferencer:
    """Advanced type inference with numeric promotion, containers, and unions."""
    
    BUILTIN_TYPES = {
        "int", "double", "bool", "std::string", "float",
        "long", "unsigned int", "unsigned long", "char"
    }
    
    PYTHON_TYPE_MAP = {
        "int": "int",
        "float": "double",
        "str": "std::string",
        "bool": "bool",
        "list": "std::vector<std::any>",
        "dict": "std::map<std::string, std::any>",
        "set": "std::set<std::any>",
        "tuple": "std::tuple<std::any>",
        "None": "void*",
        "bytes": "std::string",
    }
    
    @staticmethod
    def infer_from_value(node: ast.expr) -> str:
        """Infer C++ type from Python AST value node."""
        if isinstance(node, ast.Constant):
            if isinstance(node.value, bool):
                return "bool"
            if isinstance(node.value, int):
                return "int"
            if isinstance(node.value, float):
                return "double"
            if isinstance(node.value, str):
                return "std::string"
            if node.value is None:
                return "void*"
            return "std::any"
        
        if isinstance(node, ast.List):
            if not node.elts:
                return "std::vector<std::any>"
            inner = TypeInferencer.infer_from_value(node.elts[0])
            if inner == "std::any":
                return "std::vector<std::any>"
            return f"std::vector<{inner}>"
        
        if isinstance(node, ast.Set):
            if not node.elts:
                return "std::set<std::any>"
            inner = TypeInferencer.infer_from_value(node.elts[0])
            return f"std::set<{inner}>"
        
        if isinstance(node, ast.Tuple):
            if not node.elts:
                return "std::tuple<>"
            inferred = [TypeInferencer.infer_from_value(e) for e in node.elts]
            return f"std::tuple<{', '.join(inferred)}>"
        
        if isinstance(node, ast.Dict):
            if not node.keys:
                return "std::map<std::string, std::any>"
            k_type = TypeInferencer.infer_from_value(node.keys[0]) if node.keys else "std::string" # pyright: ignore[reportArgumentType]
            v_type = TypeInferencer.infer_from_value(node.values[0]) if node.values else "std::any"
            return f"std::map<{k_type}, {v_type}>"
        
        if isinstance(node, ast.BinOp):
            return TypeInferencer._infer_binop(node)
        
        if isinstance(node, ast.Call):
            return TypeInferencer._infer_call(node)
        
        if isinstance(node, ast.UnaryOp):
            return TypeInferencer.infer_from_value(node.operand)
        
        if isinstance(node, ast.ListComp) or isinstance(node, ast.SetComp):
            return "std::vector<std::any>"
        
        if isinstance(node, ast.DictComp):
            return "std::map<std::string, std::any>"
        
        return "std::any"
    
    @staticmethod
    def _infer_binop(node: ast.BinOp) -> str:
        left = TypeInferencer.infer_from_value(node.left)
        right = TypeInferencer.infer_from_value(node.right)
        
        # Numeric promotion
        numeric = {"int", "double", "float"}
        if left in numeric and right in numeric:
            if "double" in (left, right) or "float" in (left, right):
                return "double"
            return "int"
        
        # String concatenation
        if left == "std::string" or right == "std::string":
            if isinstance(node.op, ast.Add):
                return "std::string"
        
        return "auto"
    
    @staticmethod
    def _infer_call(node: ast.Call) -> str:
        if not isinstance(node.func, ast.Name):
            return "std::any"
        
        func_name = node.func.id
        func_map = {
            "input": "std::string",
            "range": "std::vector<int>",
            "str": "std::string",
            "int": "int",
            "float": "double",
            "bool": "bool",
            "list": "std::vector<std::any>",
            "dict": "std::map<std::string, std::any>",
            "set": "std::set<std::any>",
            "tuple": "std::tuple<std::any>",
            "len": "int",
            "map": "std::vector<std::any>",
            "filter": "std::vector<std::any>",
            "zip": "std::vector<std::pair<std::any, std::any>>",
            "enumerate": "std::vector<std::pair<int, std::any>>",
            "sum": "double",
            "min": "std::any",
            "max": "std::any",
            "sorted": "std::vector<std::any>",
            "reversed": "std::vector<std::any>",
            "any": "bool",
            "all": "bool",
        }
        return func_map.get(func_name, func_name)
    
    @staticmethod
    def infer_from_annotation(annotation: Optional[ast.expr]) -> str:
        """Infer C++ type from Python type annotation."""
        if annotation is None:
            return "auto"
        
        if isinstance(annotation, ast.Name):
            return TypeInferencer.PYTHON_TYPE_MAP.get(annotation.id, "std::any")
        
        if isinstance(annotation, ast.Subscript):
            if isinstance(annotation.value, ast.Name):
                base = annotation.value.id
                if base in ("List", "list"):
                    inner = TypeInferencer.infer_from_annotation(annotation.slice)
                    return f"std::vector<{inner}>"
                if base in ("Dict", "dict"):
                    return "std::map<std::string, std::any>"
                if base in ("Set", "set"):
                    inner = TypeInferencer.infer_from_annotation(annotation.slice)
                    return f"std::set<{inner}>"
                if base in ("Optional", "option"):
                    inner = TypeInferencer.infer_from_annotation(annotation.slice)
                    return f"std::optional<{inner}>"
                if base in ("Tuple", "tuple"):
                    return "std::tuple<std::any>"
        
        if isinstance(annotation, ast.UnionType): # pyright: ignore[reportAttributeAccessIssue]
            return "std::variant<std::any>"
        
        return "std::any"

# ═══════════════════════════════════════════════════════════════════════════
# SCOPE & SYMBOL TABLE
# ═══════════════════════════════════════════════════════════════════════════

@dataclass
class Symbol:
    """Represents a symbol in the symbol table."""
    name: str
    cpp_type: str
    is_mutable: bool = True
    is_defined: bool = False
    is_constant: bool = False

class Scope:
    """Manages variables and scoping."""
    
    def __init__(self, parent: Optional["Scope"] = None, scope_type: str = "block"):
        self.parent = parent
        self.symbols: Dict[str, Symbol] = {}
        self.scope_type = scope_type
        self.captured_vars: Set[str] = set()
    
    def define(self, name: str, cpp_type: str, is_mutable: bool = True, is_constant: bool = False) -> None:
        self.symbols[name] = Symbol(name, cpp_type, is_mutable, is_defined=True, is_constant=is_constant)
    
    def resolve(self, name: str) -> Optional[Symbol]:
        if name in self.symbols:
            return self.symbols[name]
        return self.parent.resolve(name) if self.parent else None
    
    def exists(self, name: str) -> bool:
        return self.resolve(name) is not None
    
    def get_type(self, name: str) -> str:
        symbol = self.resolve(name)
        return symbol.cpp_type if symbol else "std::any"

# ═══════════════════════════════════════════════════════════════════════════
# ADVANCED TRANSPILER ENGINE
# ═══════════════════════════════════════════════════════════════════════════

class Transpiler(ast.NodeVisitor):
    """Advanced AST-based Python to C++20 transpiler."""
    
    def __init__(self, source: str, logger: Logger):
        self.source = source
        self.logger = logger
        self.buffer: List[str] = []
        self.indent_level = 0
        self.scopes: List[Scope] = [Scope(scope_type="module")]
        self.current_class: Optional[str] = None
        self.class_members: Dict[str, str] = {}
        self.current_function: Optional[str] = None
        self.in_function = False
        self.current_return_type = "void"
        self.generator_functions: Set[str] = set()
        self.lambda_counter = 0
        self.comprehension_counter = 0
        self.try_except_counter = 0
        self.comments = extract_comments(source)
        self.used_comment_lines: Set[int] = set()
        self.global_vars: Set[str] = set()
        self.decorator_stack: List[List[str]] = []
    
    def push_scope(self, scope_type: str = "block") -> None:
        self.scopes.append(Scope(self.scopes[-1], scope_type))
    
    def pop_scope(self) -> None:
        if len(self.scopes) > 1:
            self.scopes.pop()
    
    def current_scope(self) -> Scope:
        return self.scopes[-1]
    
    def emit_comments_before(self, lineno: int) -> None:
        """Emit comments that appear before a given line number."""
        for line in sorted(self.comments.keys()):
            if line < lineno and line not in self.used_comment_lines:
                for c in self.comments[line]:
                    self.emit(f"// {c}")
                self.used_comment_lines.add(line)
    
    def emit(self, code: str) -> None:
        """Emit indented C++ code."""
        if code.strip():
            indent = "    " * self.indent_level
            self.buffer.append(f"{indent}{code}")
        else:
            self.buffer.append("")
    
    def transpile(self) -> str:
        """Main transpilation entry point."""
        try:
            tree = ast.parse(self.source)
            self.visit(tree)
            return "\n".join(self.buffer)
        except Exception as e:
            self.logger.error(f"Transpilation failed: {e}")
            raise
    
    # ─────────────────────────────────────────────────────────────────────
    # Module & Global Structure
    # ─────────────────────────────────────────────────────────────────────
    
    def visit_Module(self, node: ast.Module) -> None:
        """Process module: collect definitions, then generate main."""
        self.logger.stats['nodes'] += 1
        
        # First pass: collect class and function definitions
        for stmt in node.body:
            if isinstance(stmt, (ast.ClassDef, ast.FunctionDef)):
                self.visit(stmt)
            elif isinstance(stmt, ast.Global):
                for name in stmt.names:
                    self.global_vars.add(name)
        
        # Emit main function
        self.emit("\n// ═══════════════════════════════════════════════════════")
        self.emit("// MAIN ENTRY POINT")
        self.emit("// ═══════════════════════════════════════════════════════")
        self.emit("int main() {")
        self.indent_level += 1
        self.emit("std::ios::sync_with_stdio(false);")
        self.emit("")
        
        has_code = False
        for stmt in node.body:
            if not isinstance(stmt, (ast.ClassDef, ast.FunctionDef, ast.Import, ast.ImportFrom, ast.Global)):
                self.visit(stmt)
                has_code = True
        
        if not has_code:
            self.emit("// No executable code")
        
        self.emit("")
        self.emit("return 0;")
        self.indent_level -= 1
        self.emit("}")
    
    # ─────────────────────────────────────────────────────────────────────
    # Class Definitions
    # ─────────────────────────────────────────────────────────────────────
    
    def visit_ClassDef(self, node: ast.ClassDef) -> None:
        """Generate C++ class definition with inheritance support."""
        self.emit_comments_before(node.lineno)
        self.logger.stats['nodes'] += 1
        self.logger.stats['classes'] += 1
        
        name = node.name
        bases = [b.id for b in node.bases if isinstance(b, ast.Name)]
        inheritance = f" : public {', public '.join(bases)}" if bases else ""
        
        self.emit(f"class {name}{inheritance} {{")
        self.emit("public:")
        self.indent_level += 1
        
        self.push_scope("class")
        old_class = self.current_class
        self.current_class = name
        self.class_members = {}
        
        # Scan for member variables
        self._scan_class_members(node)
        
        # Emit member variables
        for member_name, member_type in sorted(self.class_members.items()):
            self.emit(f"{member_type} {member_name};")
        
        if self.class_members:
            self.emit("")
        
        # Process methods
        for stmt in node.body:
            if isinstance(stmt, ast.FunctionDef):
                self._visit_method(stmt)
            elif isinstance(stmt, ast.Pass):
                pass
        
        self.current_class = old_class
        self.pop_scope()
        self.indent_level -= 1
        self.emit("};")
        self.emit("")
    
    def _scan_class_members(self, node: ast.ClassDef) -> None:
        """Extract member variables from __init__."""
        for stmt in node.body:
            if isinstance(stmt, ast.FunctionDef) and stmt.name == "__init__":
                for substmt in stmt.body:
                    if isinstance(substmt, ast.Assign):
                        for target in substmt.targets:
                            if isinstance(target, ast.Attribute):
                                if isinstance(target.value, ast.Name) and target.value.id == "self":
                                    member_name = target.attr
                                    member_type = TypeInferencer.infer_from_value(substmt.value)
                                    self.class_members[member_name] = member_type
    
    def _visit_method(self, node: ast.FunctionDef) -> None:
        """Process class method."""
        self.push_scope("function")
        old_function = self.current_function
        self.current_function = node.name
        self.in_function = True
        
        # Infer return type
        ret_type = self._infer_return_type(node)
        self.current_return_type = ret_type
        
        # Process arguments
        args_list = []
        for arg in node.args.args:
            if arg.arg != "self":
                arg_type = TypeInferencer.infer_from_annotation(arg.annotation)
                args_list.append(f"{arg_type} {arg.arg}")
                self.current_scope().define(arg.arg, arg_type)
        
        args_str = ", ".join(args_list)
        
        # Emit signature
        if node.name == "__init__":
            self.emit(f"{self.current_class}({args_str}) {{")
        else:
            self.emit(f"{ret_type} {node.name}({args_str}) {{")
        
        self.indent_level += 1
        
        # Process body
        for stmt in node.body:
            self.visit(stmt)
        
        self.indent_level -= 1
        self.emit("}")
        
        self.in_function = False
        self.current_function = old_function
        self.pop_scope()
    
    # ─────────────────────────────────────────────────────────────────────
    # Function Definitions
    # ─────────────────────────────────────────────────────────────────────
    
    def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
        """Generate standalone function."""
        self.emit_comments_before(node.lineno)
        
        if self.current_class:
            return  # Handled by _visit_method
        
        self.logger.stats['nodes'] += 1
        self.logger.stats['functions'] += 1
        
        # Check if function contains yield (is a generator)
        has_yield = any(isinstance(n, ast.Yield) for n in ast.walk(node))
        if has_yield:
            self.generator_functions.add(node.name)
            self.logger.warn(f"Generator function '{node.name}' converted to regular function returning vector")
        
        self.push_scope("function")
        old_function = self.current_function
        self.current_function = node.name
        self.in_function = True
        
        ret_type = self._infer_return_type(node)
        self.current_return_type = ret_type
        
        # Process arguments
        args_list = []
        for arg in node.args.args:
            arg_type = TypeInferencer.infer_from_annotation(arg.annotation)
            args_list.append(f"{arg_type} {arg.arg}")
            self.current_scope().define(arg.arg, arg_type)
        
        args_str = ", ".join(args_list)
        self.emit(f"{ret_type} {node.name}({args_str}) {{")
        self.indent_level += 1
        
        for stmt in node.body:
            self.visit(stmt)
        
        self.indent_level -= 1
        self.emit("}")
        
        self.in_function = False
        self.current_function = old_function
        self.pop_scope()
    
    def _infer_return_type(self, func: ast.FunctionDef) -> str:
        """Infer function return type."""
        if func.returns:
            return TypeInferencer.infer_from_annotation(func.returns)
        
        return_types: Set[str] = set()
        for stmt in ast.walk(func):
            if isinstance(stmt, ast.Return) and stmt.value:
                inferred = TypeInferencer.infer_from_value(stmt.value)
                if inferred != "std::any":
                    return_types.add(inferred)
        
        if return_types:
            for pref in ["int", "double", "std::string", "bool"]:
                if pref in return_types:
                    return pref
            return list(return_types)[0]
        
        return "void"
    
    # ─────────────────────────────────────────────────────────────────────
    # Control Flow Statements
    # ─────────────────────────────────────────────────────────────────────
    
    def visit_If(self, node: ast.If) -> None:
        """Process if statement."""
        self.emit_comments_before(node.lineno)
        test = self._transpile_expr(node.test)
        self.emit(f"if ({test}) {{")
        self.indent_level += 1
        
        for stmt in node.body:
            self.visit(stmt)
        
        self.indent_level -= 1
        
        if node.orelse:
            self.emit("} else {")
            self.indent_level += 1
            
            for stmt in node.orelse:
                self.visit(stmt)
            
            self.indent_level -= 1
        
        self.emit("}")
    
    def visit_While(self, node: ast.While) -> None:
        """Process while loop."""
        self.emit_comments_before(node.lineno)
        test = self._transpile_expr(node.test)
        self.emit(f"while ({test}) {{")
        self.indent_level += 1
        
        for stmt in node.body:
            self.visit(stmt)
        
        self.indent_level -= 1
        self.emit("}")
    
    def visit_For(self, node: ast.For) -> None:
        """Process for loop with range optimization."""
        self.emit_comments_before(node.lineno)
        
        if not isinstance(node.target, ast.Name):
            return
        
        target = node.target.id
        
        # Optimize: for i in range(n)
        if self._is_range_call(node.iter):
            args = self._get_range_args(node.iter) # pyright: ignore[reportArgumentType]
            if len(args) == 1:
                start, stop, step = "0", args[0], "1"
            elif len(args) == 2:
                start, stop, step = args[0], args[1], "1"
            else:
                start, stop, step = args[0], args[1], args[2]
            
            self.current_scope().define(target, "int")
            self.emit(f"for (int {target} = {start}; {target} < {stop}; {target} += {step}) {{")
        else:
            # Generic range-based for
            iterable = self._transpile_expr(node.iter)
            self.current_scope().define(target, "auto")
            self.emit(f"for (auto {target} : {iterable}) {{")
        
        self.indent_level += 1
        
        for stmt in node.body:
            self.visit(stmt)
        
        self.indent_level -= 1
        self.emit("}")
    
    def _is_range_call(self, node: ast.expr) -> bool:
        """Check if node is a range() call."""
        return (isinstance(node, ast.Call) and 
                isinstance(node.func, ast.Name) and 
                node.func.id == "range")
    
    def _get_range_args(self, node: ast.Call) -> List[str]:
        """Extract range() arguments as strings."""
        return [self._transpile_expr(a) for a in node.args]
    
    def visit_Break(self, node: ast.Break) -> None:
        self.emit_comments_before(node.lineno)
        self.emit("break;")
    
    def visit_Continue(self, node: ast.Continue) -> None:
        self.emit_comments_before(node.lineno)
        self.emit("continue;")
    
    # ─────────────────────────────────────────────────────────────────────
    # Assignment & Variables
    # ─────────────────────────────────────────────────────────────────────
    
    def visit_Assign(self, node: ast.Assign) -> None:
        self.emit_comments_before(node.lineno)
        value_expr = self._transpile_expr(node.value)
        inferred_type = TypeInferencer.infer_from_value(node.value)
        
        for target in node.targets:
            if isinstance(target, ast.Name):
                name = target.id
                sym = self.current_scope().resolve(name)
                
                if sym is None:
                    self.current_scope().define(name, inferred_type)
                    self.emit(f"{inferred_type} {name} = {value_expr};")
                else:
                    self.emit(f"{name} = {value_expr};")
    
    def visit_AugAssign(self, node: ast.AugAssign) -> None:
        self.emit_comments_before(node.lineno)
        target = self._transpile_expr(node.target)
        op = self._map_operator(node.op)
        value = self._transpile_expr(node.value)
        self.emit(f"{target} {op}= {value};")
    
    # ─────────────────────────────────────────────────────────────────────
    # Function Calls & Returns
    # ─────────────────────────────────────────────────────────────────────
    
    def visit_Return(self, node: ast.Return) -> None:
        self.emit_comments_before(node.lineno)
        if node.value:
            expr = self._transpile_expr(node.value)
            self.emit(f"return {expr};")
        else:
            self.emit("return;")
    
    def visit_Expr(self, node: ast.Expr) -> None:
        self.emit_comments_before(node.lineno)
        expr = self._transpile_expr(node.value)
        self.emit(f"{expr};")
    
    def visit_Pass(self, node: ast.Pass) -> None:
        self.emit_comments_before(node.lineno)
        self.emit("// pass")
    
    # ─────────────────────────────────────────────────────────────────────
    # Exception Handling
    # ─────────────────────────────────────────────────────────────────────
    
    def visit_Try(self, node: ast.Try) -> None:
        """Process try/except/finally."""
        self.emit_comments_before(node.lineno)
        self.emit("try {")
        self.indent_level += 1
        
        for stmt in node.body:
            self.visit(stmt)
        
        self.indent_level -= 1
        self.emit("}")
        
        for handler in node.handlers:
            self.visit(handler)
        
        if node.finalbody:
            self.emit("// finally block (simulated)")
            for stmt in node.finalbody:
                self.visit(stmt)
    
    def visit_ExceptHandler(self, node: ast.ExceptHandler) -> None:
        """Process except clause."""
        exception_type = "std::exception"
        if node.type:
            if isinstance(node.type, ast.Name):
                exc_map = {
                    "Exception": "std::exception",
                    "ValueError": "std::invalid_argument",
                    "RuntimeError": "std::runtime_error",
                    "KeyError": "std::out_of_range",
                }
                exception_type = exc_map.get(node.type.id, "std::exception")
        
        var_name = f"__exc_{self.try_except_counter}"
        self.try_except_counter += 1
        
        self.emit(f"catch (const {exception_type}& {var_name}) {{")
        self.indent_level += 1
        
        for stmt in node.body:
            self.visit(stmt)
        
        self.indent_level -= 1
        self.emit("}")
    
    # ─────────────────────────────────────────────────────────────────────
    # Expression Transpilation
    # ─────────────────────────────────────────────────────────────────────
    
    def _transpile_expr(self, node: ast.expr) -> str:
        """Transpile expression to C++ code."""
        if node is None:
            return "nullptr"
        
        if isinstance(node, ast.Constant):
            return self._transpile_constant(node)
        
        if isinstance(node, ast.Name):
            return "(*this)" if node.id == "self" else node.id
        
        if isinstance(node, ast.JoinedStr):
            return self._transpile_fstring(node)
        
        if isinstance(node, ast.BinOp):
            left = self._transpile_expr(node.left)
            right = self._transpile_expr(node.right)
            op = self._map_operator(node.op)
            return f"({left} {op} {right})"
        
        if isinstance(node, ast.Compare):
            return self._transpile_compare(node)
        
        if isinstance(node, ast.BoolOp):
            return self._transpile_boolop(node)
        
        if isinstance(node, ast.UnaryOp):
            op = self._map_operator(node.op) # pyright: ignore[reportArgumentType]
            operand = self._transpile_expr(node.operand)
            return f"{op}{operand}"
        
        if isinstance(node, ast.Call):
            return self._transpile_call(node)
        
        if isinstance(node, ast.List):
            return self._transpile_list(node)
        
        if isinstance(node, ast.Tuple):
            return self._transpile_tuple(node)
        
        if isinstance(node, ast.Set):
            return self._transpile_set(node)
        
        if isinstance(node, ast.Dict):
            return self._transpile_dict(node)
        
        if isinstance(node, ast.ListComp):
            return self._transpile_list_comp(node)
        
        if isinstance(node, ast.SetComp):
            return self._transpile_set_comp(node)
        
        if isinstance(node, ast.DictComp):
            return self._transpile_dict_comp(node)
        
        if isinstance(node, ast.Lambda):
            return self._transpile_lambda(node)
        
        if isinstance(node, ast.Attribute):
            val = self._transpile_expr(node.value)
            return f"{val}.{node.attr}"
        
        if isinstance(node, ast.Subscript):
            val = self._transpile_expr(node.value)
            idx = self._transpile_expr(node.slice)
            return f"{val}[{idx}]"
        
        if isinstance(node, ast.IfExp):
            test = self._transpile_expr(node.test)
            body = self._transpile_expr(node.body)
            orelse = self._transpile_expr(node.orelse)
            return f"({test} ? {body} : {orelse})"
        
        return "/* UNKNOWN_EXPR */"
    
    def _transpile_constant(self, node: ast.Constant) -> str:
        """Handle constant values."""
        if isinstance(node.value, str):
            escaped = node.value.replace("\\", "\\\\").replace('"', '\\"')
            return f'std::string("{escaped}")'
        if isinstance(node.value, bool):
            return "true" if node.value else "false"
        if node.value is None:
            return "nullptr"
        if isinstance(node.value, (int, float)):
            return str(node.value)
        return "std::any()"
    
    def _transpile_fstring(self, node: ast.JoinedStr) -> str:
        """Handle f-strings."""
        parts = []
        for v in node.values:
            if isinstance(v, ast.Constant):
                escaped = str(v.value).replace("\\", "\\\\").replace('"', '\\"')
                parts.append(f'std::string("{escaped}")')
            elif isinstance(v, ast.FormattedValue):
                expr = self._transpile_expr(v.value)
                parts.append(f"str_cast({expr})")
        
        if not parts:
            return 'std::string("")'
        return " + ".join(parts)
    
    def _transpile_compare(self, node: ast.Compare) -> str:
        """Handle comparison chains."""
        left = self._transpile_expr(node.left)
        result = left
        
        for op, comp in zip(node.ops, node.comparators):
            op_str = self._map_operator(op) # pyright: ignore[reportArgumentType]
            right = self._transpile_expr(comp)
            result = f"({result} {op_str} {right})"
        
        return result
    
    def _transpile_boolop(self, node: ast.BoolOp) -> str:
        """Handle boolean operations."""
        op = "&&" if isinstance(node.op, ast.And) else "||"
        values = [self._transpile_expr(v) for v in node.values]
        return f"({f' {op} '.join(values)})"
    
    def _transpile_call(self, node: ast.Call) -> str:
        """Transpile function/method calls."""
        if isinstance(node.func, ast.Name):
            func_name = node.func.id
            
            # Built-in I/O
            if func_name == "input":
                if node.args:
                    prompt = self._transpile_expr(node.args[0])
                    return f"input({prompt})"
                return "input()"
            
            if func_name == "print":
                args = [self._transpile_expr(a) for a in node.args]
                return f"print({', '.join(args)})" if args else "print()"
            
            # Built-in constructors
            builtin_map = {
                "int": lambda a: f"int_cast({self._transpile_expr(a[0])})" if a else "0",
                "float": lambda a: f"float_cast({self._transpile_expr(a[0])})" if a else "0.0",
                "str": lambda a: f"str_cast({self._transpile_expr(a[0])})" if a else "std::string()",
                "bool": lambda a: f"bool_cast({self._transpile_expr(a[0])})" if a else "false",
                "list": lambda a: self._transpile_list(ast.List(elts=node.args, ctx=ast.Load())),
                "dict": lambda a: "std::map<std::string, std::any>{}",
                "set": lambda a: "std::set<std::any>{}",
                "len": lambda a: f"len({self._transpile_expr(a[0])})" if a else "0",
                "range": lambda a: f"range({', '.join(self._transpile_expr(x) for x in node.args)})",
                "sum": lambda a: f"sum_py({self._transpile_expr(a[0])})" if a else "0",
                "min": lambda a: f"min_py({self._transpile_expr(a[0])})" if a else "0",
                "max": lambda a: f"max_py({self._transpile_expr(a[0])})" if a else "0",
                "sorted": lambda a: f"sorted_py({self._transpile_expr(a[0])})" if a else "std::vector<std::any>{}",
                "reversed": lambda a: f"reversed_py({self._transpile_expr(a[0])})" if a else "std::vector<std::any>{}",
                "any": lambda a: f"any_of({self._transpile_expr(a[0])})" if a else "false",
                "all": lambda a: f"all_of({self._transpile_expr(a[0])})" if a else "true",
                "enumerate": lambda a: f"enumerate({self._transpile_expr(a[0])})" if a else "std::vector<std::pair<int, std::any>>{}",
                "zip": lambda a: f"zip({', '.join(self._transpile_expr(x) for x in node.args)})" if len(node.args) >= 2 else "std::vector<std::pair<std::any, std::any>>{}",
            }
            
            if func_name in builtin_map:
                return builtin_map[func_name](node.args)
        
        # Method calls
        if isinstance(node.func, ast.Attribute):
            obj = self._transpile_expr(node.func.value)
            method = node.func.attr
            args = [self._transpile_expr(a) for a in node.args]
            
            method_map = {
                "append": lambda: f"{obj}.push_back({args[0]})" if args else "",
                "pop": lambda: f"{obj}.pop_back()" if not args else f"{obj}.erase({obj}.begin() + {args[0]})",
                "clear": lambda: f"{obj}.clear()",
                "update": lambda: f"/* dict.update() not directly supported */",
                "keys": lambda: f"/* {obj}.keys() */",
                "values": lambda: f"/* {obj}.values() */",
                "items": lambda: f"/* {obj}.items() */",
                "split": lambda: f"/* {obj}.split({args[0] if args else ''}) */",
                "join": lambda: f"/* {obj}.join() */",
                "upper": lambda: f"/* {obj}.upper() */",
                "lower": lambda: f"/* {obj}.lower() */",
                "strip": lambda: f"/* {obj}.strip() */",
                "replace": lambda: f"/* {obj}.replace() */",
            }
            
            if method in method_map:
                return method_map[method]()
            
            return f"{obj}.{method}({', '.join(args)})"
        
        # Generic function call
        func_expr = self._transpile_expr(node.func)
        args = [self._transpile_expr(a) for a in node.args]
        return f"{func_expr}({', '.join(args)})"
    
    def _transpile_list(self, node: ast.List) -> str:
        """Handle list literals."""
        if not node.elts:
            return "std::vector<std::any>{}"
        
        elts = [self._transpile_expr(e) for e in node.elts]
        inner_type = TypeInferencer.infer_from_value(node.elts[0])
        return f"std::vector<{inner_type}>{{{', '.join(elts)}}}"
    
    def _transpile_tuple(self, node: ast.Tuple) -> str:
        """Handle tuple literals."""
        if not node.elts:
            return "std::tuple<>()"
        
        elts = [self._transpile_expr(e) for e in node.elts]
        types = [TypeInferencer.infer_from_value(e) for e in node.elts]
        return f"std::make_tuple({', '.join(elts)})"
    
    def _transpile_set(self, node: ast.Set) -> str:
        """Handle set literals."""
        if not node.elts:
            return "std::set<std::any>{}"
        
        elts = [self._transpile_expr(e) for e in node.elts]
        inner_type = TypeInferencer.infer_from_value(node.elts[0])
        return f"std::set<{inner_type}>{{{', '.join(elts)}}}"
    
    def _transpile_dict(self, node: ast.Dict) -> str:
        """Handle dict literals."""
        if not node.keys:
            return "std::map<std::string, std::any>{}"
        
        items = []
        for k, v in zip(node.keys, node.values):
            key = self._transpile_expr(k) # pyright: ignore[reportArgumentType]
            val = self._transpile_expr(v)
            items.append(f"{{{key}, {val}}}")
        
        return f"std::map<std::string, std::any>{{{', '.join(items)}}}"
    
    def _transpile_list_comp(self, node: ast.ListComp) -> str:
        """Handle list comprehensions."""
        self.comprehension_counter += 1
        comp_id = self.comprehension_counter
        var_name = f"__comp_result_{comp_id}"
        
        self.emit(f"auto {var_name} = []() {{")
        self.indent_level += 1
        self.emit(f"std::vector<std::any> __result;")
        
        # Generate nested loops from comprehensions
        for i, comp in enumerate(node.generators):
            target = comp.target.id if isinstance(comp.target, ast.Name) else "item"
            iter_expr = self._transpile_expr(comp.iter)
            
            indent = i + 1
            self.emit(f"for (auto {target} : {iter_expr}) {{")
            self.indent_level += 1
            
            # Add conditions
            for if_clause in comp.ifs:
                cond = self._transpile_expr(if_clause)
                self.emit(f"if ({cond}) {{")
                self.indent_level += 1
        
        # Emit the element
        elt = self._transpile_expr(node.elt)
        self.emit(f"__result.push_back({elt});")
        
        # Close loops
        for _ in node.generators:
            for _ in comp.ifs:
                self.indent_level -= 1
                self.emit("}")
            self.indent_level -= 1
            self.emit("}")
        
        self.emit("return __result;")
        self.indent_level -= 1
        self.emit(f"}}();")
        
        return var_name
    
    def _transpile_set_comp(self, node: ast.SetComp) -> str:
        """Handle set comprehensions."""
        self.comprehension_counter += 1
        comp_id = self.comprehension_counter
        var_name = f"__set_comp_{comp_id}"
        
        self.emit(f"auto {var_name} = []() {{")
        self.indent_level += 1
        self.emit(f"std::set<std::any> __result;")
        
        for comp in node.generators:
            target = comp.target.id if isinstance(comp.target, ast.Name) else "item"
            iter_expr = self._transpile_expr(comp.iter)
            self.emit(f"for (auto {target} : {iter_expr}) {{")
            self.indent_level += 1
            
            for if_clause in comp.ifs:
                cond = self._transpile_expr(if_clause)
                self.emit(f"if ({cond}) {{")
                self.indent_level += 1
        
        elt = self._transpile_expr(node.elt)
        self.emit(f"__result.insert({elt});")
        
        for _ in node.generators:
            for _ in comp.ifs:
                self.indent_level -= 1
                self.emit("}")
            self.indent_level -= 1
            self.emit("}")
        
        self.emit("return __result;")
        self.indent_level -= 1
        self.emit(f"}}();")
        
        return var_name
    
    def _transpile_dict_comp(self, node: ast.DictComp) -> str:
        """Handle dict comprehensions."""
        self.comprehension_counter += 1
        comp_id = self.comprehension_counter
        var_name = f"__dict_comp_{comp_id}"
        
        self.emit(f"auto {var_name} = []() {{")
        self.indent_level += 1
        self.emit(f"std::map<std::string, std::any> __result;")
        
        for comp in node.generators:
            target = comp.target.id if isinstance(comp.target, ast.Name) else "item"
            iter_expr = self._transpile_expr(comp.iter)
            self.emit(f"for (auto {target} : {iter_expr}) {{")
            self.indent_level += 1
            
            for if_clause in comp.ifs:
                cond = self._transpile_expr(if_clause)
                self.emit(f"if ({cond}) {{")
                self.indent_level += 1
        
        key = self._transpile_expr(node.key)
        val = self._transpile_expr(node.value)
        self.emit(f"__result[{key}] = {val};")
        
        for _ in node.generators:
            for _ in comp.ifs:
                self.indent_level -= 1
                self.emit("}")
            self.indent_level -= 1
            self.emit("}")
        
        self.emit("return __result;")
        self.indent_level -= 1
        self.emit(f"}}();")
        
        return var_name
    
    def _transpile_lambda(self, node: ast.Lambda) -> str:
        """Handle lambda expressions."""
        self.lambda_counter += 1
        
        args = []
        for arg in node.args.args:
            args.append(arg.arg)
        
        arg_str = ", ".join(args)
        body = self._transpile_expr(node.body)
        
        return f"[](const auto& {arg_str}) {{ return {body}; }}"
    
    def _map_operator(self, op: ast.operator) -> str:
        """Map Python operators to C++."""
        mapping = {
            ast.Add: "+",
            ast.Sub: "-",
            ast.Mult: "*",
            ast.Div: "/",
            ast.FloorDiv: "/",
            ast.Mod: "%",
            ast.Pow: "pow",
            ast.Eq: "==",
            ast.NotEq: "!=",
            ast.Lt: "<",
            ast.LtE: "<=",
            ast.Gt: ">",
            ast.GtE: ">=",
            ast.And: "&&",
            ast.Or: "||",
            ast.BitAnd: "&",
            ast.BitOr: "|",
            ast.BitXor: "^",
            ast.LShift: "<<",
            ast.RShift: ">>",
            ast.USub: "-",
            ast.Not: "!",
            ast.Invert: "~",
        }
        return mapping.get(type(op), "?")

# ═══════════════════════════════════════════════════════════════════════════
# BUILD PIPELINE
# ═══════════════════════════════════════════════════════════════════════════

def compile_cpp(cpp_file: Path, output_exe: Path, config: TranspileConfig, logger: Logger) -> bool:
    """Compile C++ to binary using g++."""
    cmd = [
        "g++",
        f"-std={config.cpp_standard}",
        config.optimize,
        "-Wall", "-Wextra",
        "-flto",
        "-s",
    ]
    
    if platform.system() != "Windows":
        cmd.append("-pthread")
    
    cmd.extend([str(cpp_file), "-o", str(output_exe)])
    
    logger.debug(f"Compile cmd: {' '.join(cmd)}")
    
    try:
        start = time.time()
        result = subprocess.run(
            cmd,
            capture_output=True,
            text=True,
            encoding="utf-8",
            errors="replace",
            timeout=120
        )
        elapsed = time.time() - start
        
        if result.returncode != 0:
            logger.error(f"Compilation failed in {elapsed:.2f}s")
            if result.stderr:
                typer.echo(result.stderr)
            return False
        
        logger.success(f"Binary compiled: {output_exe} ({elapsed:.2f}s)")
        return True
    
    except FileNotFoundError:
        logger.error("g++ not found in PATH")
        return False
    except subprocess.TimeoutExpired:
        logger.error("Compilation timeout (>120s)")
        return False
    except Exception as e:
        logger.error(f"Compilation error: {e}")
        return False

# ═══════════════════════════════════════════════════════════════════════════
# CLI
# ═══════════════════════════════════════════════════════════════════════════

app = Typer(help="🔥 Py2Cpp Ultimate v2.0 - Python to C++20 Transpiler")

@app.command()
def main(
    input_file: Path = typer.Argument(..., help="Python source file", exists=True),
    output: Optional[Path] = typer.Option(None, "--output", "-o", help="Output binary path"),
    cpp_std: str = typer.Option("c++20", "--std", help="C++ standard"),
    optimize: OptLevel = typer.Option(OptLevel.O3, "--optimize", "-O", help="Optimization level"),
    run: bool = typer.Option(False, "--run", "-r", help="Run after compilation"),
    keep_cpp: bool = typer.Option(True, "--keep-cpp", "-k", help="Keep generated .cpp"),
    verbose: bool = typer.Option(False, "--verbose", "-v", help="Verbose output"),
) -> None:
    """
    Transpile Python to optimized C++20 code with automatic compilation.
    
    Features:
    • Classes with inheritance & polymorphism
    • Generators & comprehensions (list, dict, set)
    • Lambda expressions & higher-order functions
    • Exception handling (try/except/finally)
    • f-strings with expression interpolation
    • Type inference with numeric promotion
    • Built-in functions (print, input, range, len, sum, etc.)
    • Advanced containers (list, dict, set, tuple)
    
    Examples:
        py2cpp_ultimate main.py --run --optimize O3
        py2cpp_ultimate banksim.py -k --verbose
    """
    
    typer.echo("")
    typer.secho("┌────────────────────────────────────────────────┐", fg=typer.colors.CYAN)
    typer.secho(f"│ 🔥 Py2Cpp Ultimate v{VERSION} - Python→C++20  │", fg=typer.colors.CYAN)
    typer.secho("└────────────────────────────────────────────────┘", fg=typer.colors.CYAN)
    typer.echo("")
    
    logger = Logger(verbose=verbose)
    
    try:
        source = input_file.read_text(encoding="utf-8")
    except Exception as e:
        logger.error(f"Cannot read {input_file}: {e}")
        raise typer.Exit(1)
    
    config = TranspileConfig(
        input_file=input_file,
        output_file=output,
        cpp_standard=cpp_std,
        optimize=optimize.value,
        run=run,
        keep_cpp=keep_cpp,
        verbose=verbose
    )
    
    logger.info("Phase 1: AST Parsing & Analysis")
    transpiler = Transpiler(source, logger)
    
    try:
        cpp_code = transpiler.transpile()
    except Exception as e:
        logger.error(f"Transpilation failed: {e}")
        raise typer.Exit(1)
    
    full_cpp = CPP_PREAMBLE + "\n" + cpp_code
    
    # Determine output paths
    base = input_file.stem
    cpp_path = Path(f"{base}.cpp")
    exe_path = output if output else Path(f"{base}.exe" if platform.system() == "Windows" else base)
    
    cpp_path.write_text(full_cpp, encoding="utf-8")
    logger.success(f"Generated C++: {cpp_path} ({len(full_cpp.splitlines())} lines)")
    
    logger.info("Phase 2: Compilation (g++)")
    success = compile_cpp(cpp_path, exe_path, config, logger)
    
    if not success:
        raise typer.Exit(1)
    
    # Report
    report = logger.report()
    typer.echo("")
    typer.secho("📊 FINAL REPORT", fg=typer.colors.MAGENTA, bold=True)
    for key, val in report.items():
        typer.secho(f"  {key:.<35} {val}", fg=typer.colors.BLUE)
    typer.echo("")
    
    # Cleanup
    if not keep_cpp:
        cpp_path.unlink()
    
    # Run
    if run:
        typer.echo("")
        typer.secho("▶️  EXECUTING...", fg=typer.colors.GREEN, bold=True)
        typer.echo("")
        try:
            subprocess.run([str(exe_path)], check=False)
        except Exception as e:
            logger.error(f"Execution failed: {e}")

if __name__ == "__main__":
    app()