zexus 1.6.2

package/src/zexus/external_bridge.py

@@ -0,0 +1,16 @@
+# External function bridge for Zexus
+import hashlib
+
+external_functions = {
+    "sha256_hash": lambda data: hashlib.sha256(data.encode()).hexdigest(),
+    "generate_sphincs_keypair": lambda: {
+        "public_key": "sphincs_pub_placeholder", 
+        "private_key": "sphincs_priv_placeholder"
+    }
+}
+
+def call_external(function_name, args):
+    if function_name in external_functions:
+        return external_functions[function_name](*args)
+    else:
+        raise Exception(f"External function not found: {function_name}")

package/src/zexus/find_affected_imports.sh

@@ -0,0 +1,155 @@
+#!/bin/bash
+# find_affected_imports.sh
+echo "🔍 FINDING FILES AFFECTED BY PARSER DIRECTORY MOVE"
+echo "=================================================="
+echo ""
+
+# First, let's see what files import parser-related modules
+echo "1. Searching for files that import parser modules..."
+echo "---------------------------------------------------"
+
+# Search for imports of parser, strategy_context, strategy_structural
+patterns=(
+    "from.*\.parser"
+    "import.*parser"
+    "from.*strategy_context"
+    "from.*strategy_structural"
+    "from.*strategy_recovery"
+    "Parser.*import"
+    "UltimateParser"
+)
+
+for pattern in "${patterns[@]}"; do
+    echo ""
+    echo "📌 Searching for: $pattern"
+    echo "--------------------------------"
+    grep -r "$pattern" . --include="*.py" 2>/dev/null | \
+        grep -v "__pycache__" | \
+        grep -v "compiler/parser.py" | \
+        grep -v "parser/parser.py" | \
+        head -20
+done
+
+echo ""
+echo "2. Checking specific known files that might need updates:"
+echo "---------------------------------------------------------"
+
+# List of files likely to need updates
+critical_files=(
+    "cli/main.py"
+    "hybrid_orchestrator.py"
+    "__init__.py"
+    "syntax_validator.py"
+    "strategy_recovery.py"
+    "compiler/compat_runtime.py"
+    "compiler/__init__.py"
+    "compiler/semantic.py"
+    "vm/vm.py"
+    "evaluator/core.py"
+    "evaluator/statements.py"
+    "module_cache.py"
+    "environment_manager.py"
+    "compare_interpreter_compiler.py"
+)
+
+for file in "${critical_files[@]}"; do
+    if [ -f "$file" ]; then
+        echo ""
+        echo "🔎 Checking: $file"
+        # Check for parser imports
+        if grep -q "parser" "$file"; then
+            echo "   ⚠️  Contains 'parser' references:"
+            grep -n "parser" "$file" | head -3 | sed 's/^/      /'
+        fi
+        # Check for specific parser classes
+        if grep -q "Parser\|UltimateParser" "$file"; then
+            echo "   ⚠️  Contains parser class references:"
+            grep -n "Parser\|UltimateParser" "$file" | head -3 | sed 's/^/      /'
+        fi
+    fi
+done
+
+echo ""
+echo "3. Analyzing import patterns in parser directory:"
+echo "-------------------------------------------------"
+
+# Look at what the parser files themselves export
+echo "Parser directory structure:"
+ls -la parser/
+
+echo ""
+echo "Parser/__init__.py contents:"
+if [ -f "parser/__init__.py" ]; then
+    cat parser/__init__.py
+else
+    echo "No __init__.py in parser directory"
+fi
+
+echo ""
+echo "4. Finding import statements that need changing:"
+echo "-----------------------------------------------"
+
+# Most common patterns that need updating
+echo "Common patterns that need updating:"
+echo "  OLD: from .parser import Parser"
+echo "  NEW: from .parser.parser import Parser"
+echo ""
+echo "  OLD: from . import parser"
+echo "  NEW: from .parser import parser"
+echo ""
+echo "  OLD: from ..parser import ..."
+echo "  NEW: from ..parser.parser import ... (or from ..parser.strategy_context import ...)"
+
+echo ""
+echo "5. Running actual import test to see what breaks:"
+echo "-------------------------------------------------"
+
+# Quick Python test to see what imports work
+echo "Testing imports..."
+python3 -c "
+import sys
+sys.path.insert(0, '.')
+
+print('Testing parser imports...')
+try:
+    from parser import Parser
+    print('✓ from parser import Parser - WORKS')
+except ImportError as e:
+    print(f'✗ from parser import Parser - FAILS: {e}')
+
+try:
+    from parser.parser import Parser
+    print('✓ from parser.parser import Parser - WORKS')
+except ImportError as e:
+    print(f'✗ from parser.parser import Parser - FAILS: {e}')
+
+try:
+    from parser.strategy_context import StrategyContext
+    print('✓ from parser.strategy_context import StrategyContext - WORKS')
+except ImportError as e:
+    print(f'✗ from parser.strategy_context import StrategyContext - FAILS: {e}')
+
+try:
+    from parser.strategy_structural import StructuralStrategy
+    print('✓ from parser.strategy_structural import StructuralStrategy - WORKS')
+except ImportError as e:
+    print(f'✗ from parser.strategy_structural import StructuralStrategy - FAILS: {e}')
+"
+
+echo ""
+echo "6. Creating migration commands:"
+echo "------------------------------"
+
+# Generate sed commands for common replacements
+echo "To update imports, you might need these sed commands:"
+echo ""
+echo "# Update imports in the same directory as parser/"
+echo "sed -i 's/from \\.parser import/from \\.parser.parser import/g' *.py"
+echo "sed -i 's/from parser import/from parser.parser import/g' *.py"
+echo ""
+echo "# Update imports from parent directory"
+echo "sed -i 's/from \\.\\.parser import/from \\.\\.parser.parser import/g' *.py"
+echo ""
+echo "# Update specific strategy imports"
+echo "sed -i 's/from \\.strategy_context import/from \\.parser.strategy_context import/g' *.py"
+echo "sed -i 's/from \\.strategy_structural import/from \\.parser.strategy_structural import/g' *.py"

package/src/zexus/hybrid_orchestrator.py

@@ -0,0 +1,152 @@
+# src/zexus/hybrid_orchestrator.py
+"""
+Hybrid Orchestrator - Intelligently chooses between interpreter and compiler
+"""
+
+import os
+import time
+from .lexer import Lexer
+from .parser import UltimateParser
+# UPDATED: Import from new structure
+from .evaluator import evaluate
+from .object import Environment
+from .config import config
+
+# Try to import compiler components
+try:
+    from .compiler import ZexusCompiler
+    from .vm import ZexusVM
+    COMPILER_AVAILABLE = True
+except ImportError:
+    COMPILER_AVAILABLE = False
+
+class HybridOrchestrator:
+    def __init__(self):
+        self.interpreter_used = 0
+        self.compiler_used = 0
+        self.fallbacks = 0
+
+    def should_use_compiler(self, code, syntax_style="auto"):
+        """
+        Smart rules for when to use compiler vs interpreter
+        """
+        if not config.use_hybrid_compiler or not COMPILER_AVAILABLE:
+            return False
+
+        # Rule 1: Large files (> 100 lines) benefit from compilation
+        line_count = len(code.split('\n'))
+        if line_count > config.compiler_line_threshold:
+            return True
+
+        # Rule 2: Code with complex loops (for, while) 
+        complex_constructs = ['for', 'while', 'each', 'function', 'action']
+        if any(construct in code for construct in complex_constructs):
+            return True
+
+        # Rule 3: Mathematical/computational intensive code
+        math_keywords = ['*', '/', '%', 'math.', 'calculate']
+        if any(keyword in code for keyword in math_keywords):
+            return True
+
+        # Rule 4: User explicitly wants compilation
+        if "// compile" in code or "# compile" in code:
+            return True
+
+        # Rule 5: Universal syntax is more compiler-friendly
+        if syntax_style == "universal":
+            return True
+
+        # Default: Use interpreter for simple scripts
+        return False
+
+    def compile_and_execute(self, code, environment=None, syntax_style="auto"):
+        """
+        Execute code using the compiler/VM path
+        """
+        try:
+            if not COMPILER_AVAILABLE:
+                raise Exception("Compiler not available")
+
+            print("🔧 Compiling code...")
+
+            # Use the ZexusCompiler
+            compiler = ZexusCompiler(code)
+            bytecode = compiler.compile()
+
+            if compiler.errors:
+                raise Exception(f"Compilation errors: {compiler.errors}")
+
+            # Execute in VM
+            vm = ZexusVM(bytecode)
+            result = vm.execute()
+
+            self.compiler_used += 1
+            return result
+
+        except Exception as e:
+            print(f"❌ Compilation failed: {e}")
+            if config.fallback_to_interpreter:
+                print("🔄 Falling back to interpreter...")
+                self.fallbacks += 1
+                return self.interpret(code, environment, syntax_style)
+            else:
+                raise
+
+    def interpret(self, code, environment=None, syntax_style="auto"):
+        """
+        Execute code using the interpreter path
+        """
+        lexer = Lexer(code)
+        parser = UltimateParser(lexer, syntax_style)
+        program = parser.parse_program()
+
+        if len(parser.errors) > 0:
+            raise Exception(f"Parse errors: {parser.errors}")
+
+        if environment is None:
+            environment = Environment()
+
+        # UPDATED: Use evaluate instead of eval_node
+        result = evaluate(program, environment)
+
+        self.interpreter_used += 1
+        return result
+
+    def execute(self, code, environment=None, mode="auto", syntax_style="auto"):
+        """
+        Main entry point - decides execution strategy
+        """
+        start_time = time.time()
+
+        if mode == "interpreter":
+            result = self.interpret(code, environment, syntax_style)
+        elif mode == "compiler":
+            result = self.compile_and_execute(code, environment, syntax_style)
+        else:  # auto mode
+            if self.should_use_compiler(code, syntax_style):
+                result = self.compile_and_execute(code, environment, syntax_style)
+            else:
+                result = self.interpret(code, environment, syntax_style)
+
+        execution_time = time.time() - start_time
+
+        if config.enable_debug_logs and config.enable_execution_stats:
+            self._print_execution_stats(execution_time, mode)
+
+        return result
+
+    def _print_execution_stats(self, execution_time, mode):
+        """Print execution statistics"""
+        print(f"\n📊 Execution Statistics:")
+        print(f"   Mode: {mode}")
+        print(f"   Time: {execution_time:.4f}s")
+        print(f"   Interpreter uses: {self.interpreter_used}")
+        print(f"   Compiler uses: {self.compiler_used}")
+        print(f"   Fallbacks: {self.fallbacks}")
+        total = self.interpreter_used + self.compiler_used
+        if total > 0:
+            compiler_percent = (self.compiler_used / total) * 100
+            print(f"   Compiler usage: {compiler_percent:.1f}%")
+
+# Global orchestrator instance
+orchestrator = HybridOrchestrator()

package/src/zexus/input_validation.py

@@ -0,0 +1,259 @@
+"""
+Input Validation Module for Zexus Interpreter
+
+Provides comprehensive input validation for all public APIs to ensure
+robust error handling and prevent crashes.
+
+Location: src/zexus/input_validation.py
+"""
+
+
+def validate_string_input(value, param_name="value", allow_empty=True, max_length=None):
+    """
+    Validate string input parameters.
+    
+    Args:
+        value: The value to validate
+        param_name: Name of the parameter (for error messages)
+        allow_empty: Whether empty strings are allowed
+        max_length: Maximum allowed length (None for unlimited)
+        
+    Returns:
+        str: The validated string value
+        
+    Raises:
+        TypeError: If value is not a string
+        ValueError: If validation constraints are violated
+    """
+    if not isinstance(value, str):
+        raise TypeError(f"{param_name} must be a string, got {type(value).__name__}")
+    
+    if not allow_empty and len(value) == 0:
+        raise ValueError(f"{param_name} cannot be empty")
+    
+    if max_length is not None and len(value) > max_length:
+        raise ValueError(f"{param_name} exceeds maximum length of {max_length}")
+    
+    return value
+
+
+def validate_integer_input(value, param_name="value", min_value=None, max_value=None):
+    """
+    Validate integer input parameters.
+    
+    Args:
+        value: The value to validate
+        param_name: Name of the parameter (for error messages)
+        min_value: Minimum allowed value (None for unlimited)
+        max_value: Maximum allowed value (None for unlimited)
+        
+    Returns:
+        int: The validated integer value
+        
+    Raises:
+        TypeError: If value is not an integer
+        ValueError: If validation constraints are violated
+    """
+    if not isinstance(value, int) or isinstance(value, bool):
+        raise TypeError(f"{param_name} must be an integer, got {type(value).__name__}")
+    
+    if min_value is not None and value < min_value:
+        raise ValueError(f"{param_name} must be >= {min_value}, got {value}")
+    
+    if max_value is not None and value > max_value:
+        raise ValueError(f"{param_name} must be <= {max_value}, got {value}")
+    
+    return value
+
+
+def validate_number_input(value, param_name="value", min_value=None, max_value=None):
+    """
+    Validate numeric (int or float) input parameters.
+    
+    Args:
+        value: The value to validate
+        param_name: Name of the parameter (for error messages)
+        min_value: Minimum allowed value (None for unlimited)
+        max_value: Maximum allowed value (None for unlimited)
+        
+    Returns:
+        The validated numeric value
+        
+    Raises:
+        TypeError: If value is not numeric
+        ValueError: If validation constraints are violated
+    """
+    if not isinstance(value, (int, float)) or isinstance(value, bool):
+        raise TypeError(f"{param_name} must be numeric, got {type(value).__name__}")
+    
+    if min_value is not None and value < min_value:
+        raise ValueError(f"{param_name} must be >= {min_value}, got {value}")
+    
+    if max_value is not None and value > max_value:
+        raise ValueError(f"{param_name} must be <= {max_value}, got {value}")
+    
+    return value
+
+
+def validate_collection_input(value, param_name="value", min_length=None, max_length=None):
+    """
+    Validate collection (list, tuple, set) input parameters.
+    
+    Args:
+        value: The value to validate
+        param_name: Name of the parameter (for error messages)
+        min_length: Minimum allowed length (None for unlimited)
+        max_length: Maximum allowed length (None for unlimited)
+        
+    Returns:
+        The validated collection
+        
+    Raises:
+        TypeError: If value is not a collection
+        ValueError: If validation constraints are violated
+    """
+    if not hasattr(value, '__len__') or isinstance(value, (str, bytes)):
+        raise TypeError(f"{param_name} must be a collection, got {type(value).__name__}")
+    
+    length = len(value)
+    
+    if min_length is not None and length < min_length:
+        raise ValueError(f"{param_name} must have at least {min_length} elements, got {length}")
+    
+    if max_length is not None and length > max_length:
+        raise ValueError(f"{param_name} must have at most {max_length} elements, got {length}")
+    
+    return value
+
+
+def validate_index(index, collection, param_name="index"):
+    """
+    Validate that an index is within bounds for a collection.
+    
+    Args:
+        index: The index to validate
+        collection: The collection being indexed
+        param_name: Name of the parameter (for error messages)
+        
+    Returns:
+        int: The validated index
+        
+    Raises:
+        TypeError: If index is not an integer
+        IndexError: If index is out of bounds
+    """
+    if not isinstance(index, int) or isinstance(index, bool):
+        raise TypeError(f"{param_name} must be an integer, got {type(index).__name__}")
+    
+    if not hasattr(collection, '__len__'):
+        raise TypeError(f"Cannot index into {type(collection).__name__}")
+    
+    length = len(collection)
+    
+    # Handle negative indices
+    if index < 0:
+        index = length + index
+    
+    if index < 0 or index >= length:
+        raise IndexError(f"{param_name} {index} is out of bounds for collection of length {length}")
+    
+    return index
+
+
+def validate_file_path(path, param_name="path", must_exist=False, must_be_file=False):
+    """
+    Validate file path input.
+    
+    Args:
+        path: The file path to validate
+        param_name: Name of the parameter (for error messages)
+        must_exist: Whether the path must exist
+        must_be_file: Whether the path must be a file (not directory)
+        
+    Returns:
+        str: The validated path
+        
+    Raises:
+        TypeError: If path is not a string
+        ValueError: If validation constraints are violated
+    """
+    import os
+    
+    if not isinstance(path, str):
+        raise TypeError(f"{param_name} must be a string, got {type(path).__name__}")
+    
+    if len(path) == 0:
+        raise ValueError(f"{param_name} cannot be empty")
+    
+    if must_exist and not os.path.exists(path):
+        raise ValueError(f"{param_name} does not exist: {path}")
+    
+    if must_be_file and os.path.exists(path) and not os.path.isfile(path):
+        raise ValueError(f"{param_name} must be a file, got directory: {path}")
+    
+    return path
+
+
+def validate_enum_input(value, allowed_values, param_name="value"):
+    """
+    Validate that a value is one of a set of allowed values.
+    
+    Args:
+        value: The value to validate
+        allowed_values: Collection of allowed values
+        param_name: Name of the parameter (for error messages)
+        
+    Returns:
+        The validated value
+        
+    Raises:
+        ValueError: If value is not in allowed_values
+    """
+    if value not in allowed_values:
+        raise ValueError(
+            f"{param_name} must be one of {allowed_values}, got {value}"
+        )
+    
+    return value
+
+
+def validate_not_none(value, param_name="value"):
+    """
+    Validate that a value is not None.
+    
+    Args:
+        value: The value to validate
+        param_name: Name of the parameter (for error messages)
+        
+    Returns:
+        The validated value (not None)
+        
+    Raises:
+        ValueError: If value is None
+    """
+    if value is None:
+        raise ValueError(f"{param_name} cannot be None")
+    
+    return value
+
+
+# Convenience validators for common patterns
+
+def validate_positive_integer(value, param_name="value"):
+    """Validate that value is a positive integer (> 0)."""
+    return validate_integer_input(value, param_name, min_value=1)
+
+
+def validate_non_negative_integer(value, param_name="value"):
+    """Validate that value is a non-negative integer (>= 0)."""
+    return validate_integer_input(value, param_name, min_value=0)
+
+
+def validate_non_empty_string(value, param_name="value"):
+    """Validate that value is a non-empty string."""
+    return validate_string_input(value, param_name, allow_empty=False)
+
+
+def validate_percentage(value, param_name="value"):
+    """Validate that value is a number between 0 and 100."""
+    return validate_number_input(value, param_name, min_value=0, max_value=100)