zexus 1.6.2

package/src/zexus/concurrency_system.py

@@ -0,0 +1,493 @@
+"""
+Concurrency & Performance System for Zexus Interpreter
+
+Provides channels for message passing, atomic operations for safe concurrent access,
+and support for async/await patterns. Designed for safe, race-free concurrent programming.
+"""
+
+from typing import Dict, List, Any, Optional, Generic, TypeVar
+from dataclasses import dataclass, field
+from enum import Enum
+from threading import Lock, Condition, Event
+import queue
+import time
+
+T = TypeVar('T')
+
+# Sentinel value to signal channel is closed
+class _ChannelClosedSentinel:
+    """Sentinel object to wake up receivers when channel is closed"""
+    pass
+
+_CHANNEL_CLOSED_SENTINEL = _ChannelClosedSentinel()
+
+
+class ChannelMode(Enum):
+    """Channel communication mode"""
+    UNBUFFERED = "unbuffered"  # Blocks until receiver/sender ready
+    BUFFERED = "buffered"      # Has internal queue with capacity
+    CLOSED = "closed"          # Channel closed, no more communication
+
+
+@dataclass
+class Channel(Generic[T]):
+    """
+    Type-safe message passing channel
+    
+    Supports:
+    - Unbuffered channels (synchronization point)
+    - Buffered channels (queue with capacity)
+    - Non-blocking sends/receives
+    - Close semantics
+    
+    Example:
+        channel<integer> numbers;
+        send(numbers, 42);
+        value = receive(numbers);
+    """
+    
+    name: str
+    element_type: Optional[str] = None
+    capacity: int = 0  # 0 = unbuffered
+    _queue: queue.Queue = field(default_factory=queue.Queue)
+    _closed: bool = field(default=False)
+    _lock: Lock = field(default_factory=Lock)
+    _send_ready: Condition = field(default=None)
+    _recv_ready: Condition = field(default=None)
+    _closed_event: Event = field(default_factory=Event)
+    
+    def __post_init__(self):
+        if self.capacity > 0:
+            self._queue = queue.Queue(maxsize=self.capacity)
+        else:
+            self._queue = queue.Queue()
+        # Initialize Condition variables with the same lock
+        self._send_ready = Condition(self._lock)
+        self._recv_ready = Condition(self._lock)
+    
+    @property
+    def is_open(self) -> bool:
+        """Check if channel is open"""
+        with self._lock:
+            return not self._closed
+    
+    def send(self, value: T, timeout: Optional[float] = None) -> bool:
+        """
+        Send value to channel
+        
+        Args:
+            value: Value to send
+            timeout: Maximum wait time (None = infinite)
+            
+        Returns:
+            True if sent, False if channel closed
+            
+        Raises:
+            RuntimeError: If channel is closed
+        """
+        # Check if closed (with lock)
+        with self._lock:
+            if self._closed:
+                raise RuntimeError(f"Cannot send on closed channel '{self.name}'")
+        
+        # Send without holding lock (queue.Queue is thread-safe)
+        try:
+            if self.capacity == 0:
+                # Unbuffered: block until receiver ready
+                self._queue.put(value, timeout=timeout)
+            else:
+                # Buffered: block if full
+                self._queue.put(value, timeout=timeout)
+            
+            # Notify receiver (with lock)
+            with self._lock:
+                self._recv_ready.notify()
+            return True
+        except queue.Full:
+            raise RuntimeError(f"Channel '{self.name}' buffer full")
+        except queue.Empty:
+            raise RuntimeError(f"Timeout sending to channel '{self.name}'")
+    
+    def receive(self, timeout: Optional[float] = None) -> Optional[T]:
+        """
+        Receive value from channel (blocking)
+        
+        Args:
+            timeout: Maximum wait time (None = infinite)
+            
+        Returns:
+            Received value or None if channel closed and empty
+            
+        Raises:
+            RuntimeError: On communication error
+        """
+        # Check if closed first (with lock)
+        with self._lock:
+            if self._closed and self._queue.empty():
+                return None
+        
+        # Receive without holding lock (queue.Queue is thread-safe)
+        try:
+            value = self._queue.get(timeout=timeout)
+            
+            # Check if this is the closed sentinel
+            if isinstance(value, _ChannelClosedSentinel):
+                return None
+            
+            # Notify sender (with lock)
+            with self._lock:
+                self._send_ready.notify()
+            return value
+        except queue.Empty:
+            # Check if closed (with lock)
+            with self._lock:
+                if self._closed:
+                    return None
+            raise RuntimeError(f"Timeout receiving from channel '{self.name}'")
+    
+    def close(self):
+        """Close channel - no more sends/receives allowed"""
+        with self._lock:
+            self._closed = True
+            self._closed_event.set()
+            # Put sentinel values to wake up any waiting receivers
+            # This ensures they immediately return None instead of timing out
+            try:
+                # For buffered channels, put one sentinel
+                if self.capacity > 0:
+                    self._queue.put_nowait(_CHANNEL_CLOSED_SENTINEL)
+                # For unbuffered channels, use notification
+                else:
+                    self._recv_ready.notify_all()
+                    self._send_ready.notify_all()
+            except queue.Full:
+                # Queue is full, receivers will check closed flag anyway
+                pass
+    
+    def __repr__(self) -> str:
+        mode = f"buffered({self.capacity})" if self.capacity > 0 else "unbuffered"
+        status = "closed" if self._closed else "open"
+        return f"Channel<{self.element_type}>({self.name}, {mode}, {status})"
+
+
+@dataclass
+class Atomic:
+    """
+    Atomic operation wrapper - ensures indivisible execution
+    
+    Provides mutex-protected code region where concurrent accesses
+    cannot interleave. Useful for short, critical sections.
+    
+    Example:
+        atomic(counter = counter + 1);
+        
+        atomic {
+            x = x + 1;
+            y = y + 1;
+        };
+    """
+    
+    _lock: Lock = field(default_factory=Lock)
+    _depth: int = field(default=0)  # Reentrancy depth
+    
+    def execute(self, operation, *args, **kwargs):
+        """
+        Execute operation atomically
+        
+        Args:
+            operation: Callable to execute
+            *args: Positional arguments
+            **kwargs: Keyword arguments
+            
+        Returns:
+            Result of operation
+        """
+        with self._lock:
+            self._depth += 1
+            try:
+                return operation(*args, **kwargs)
+            finally:
+                self._depth -= 1
+    
+    def acquire(self):
+        """Acquire atomic lock (for manual control)"""
+        self._lock.acquire()
+        self._depth += 1
+    
+    def release(self):
+        """Release atomic lock (for manual control)"""
+        if self._depth > 0:
+            self._depth -= 1
+            self._lock.release()
+    
+    def is_locked(self) -> bool:
+        """Check if currently locked"""
+        return self._depth > 0
+
+
+@dataclass
+class WaitGroup:
+    """
+    Wait group for synchronizing multiple async operations
+    
+    Similar to Go's sync.WaitGroup - allows waiting for a collection
+    of tasks to complete. Useful for coordinating producer-consumer patterns.
+    
+    Example:
+        let wg = wait_group()
+        wg.add(2)  # Expecting 2 tasks
+        
+        async action task1() {
+            # ... work ...
+            wg.done()
+        }
+        
+        async action task2() {
+            # ... work ...
+            wg.done()
+        }
+        
+        async task1()
+        async task2()
+        wg.wait()  # Blocks until both tasks call done()
+    """
+    _count: int = field(default=0)
+    _lock: Lock = field(default_factory=Lock)
+    _zero_event: Event = field(default_factory=Event)
+    
+    def __post_init__(self):
+        # Start with event set (count is 0)
+        self._zero_event.set()
+    
+    def add(self, delta: int = 1):
+        """Add delta to the wait group counter"""
+        with self._lock:
+            self._count += delta
+            if self._count < 0:
+                raise ValueError("WaitGroup counter cannot be negative")
+            if self._count == 0:
+                self._zero_event.set()
+            else:
+                self._zero_event.clear()
+    
+    def done(self):
+        """Decrement the wait group counter by 1"""
+        self.add(-1)
+    
+    def wait(self, timeout: Optional[float] = None) -> bool:
+        """
+        Wait until the counter reaches zero
+        
+        Args:
+            timeout: Maximum wait time in seconds (None = infinite)
+            
+        Returns:
+            True if counter reached zero, False if timeout
+        """
+        return self._zero_event.wait(timeout=timeout)
+    
+    def count(self) -> int:
+        """Get current counter value"""
+        with self._lock:
+            return self._count
+
+
+@dataclass
+class Barrier:
+    """
+    Synchronization barrier for coordinating multiple tasks
+    
+    Allows multiple tasks to wait at a barrier point until all have arrived.
+    Once all parties arrive, all are released simultaneously.
+    
+    Example:
+        let barrier = barrier(2)  # Wait for 2 tasks
+        
+        async action task1() {
+            # ... phase 1 work ...
+            barrier.wait()  # Wait for task2
+            # ... phase 2 work ...
+        }
+        
+        async action task2() {
+            # ... phase 1 work ...
+            barrier.wait()  # Wait for task1
+            # ... phase 2 work ...
+        }
+    """
+    parties: int  # Number of tasks that must call wait()
+    _count: int = field(default=0)
+    _generation: int = field(default=0)
+    _lock: Lock = field(default_factory=Lock)
+    _condition: Condition = field(default=None)
+    
+    def __post_init__(self):
+        if self.parties <= 0:
+            raise ValueError("Barrier parties must be positive")
+        if self._condition is None:
+            self._condition = Condition(self._lock)
+    
+    def wait(self, timeout: Optional[float] = None) -> int:
+        """
+        Wait at the barrier until all parties arrive
+        
+        Args:
+            timeout: Maximum wait time in seconds (None = infinite)
+            
+        Returns:
+            Barrier generation number (increments each cycle)
+            
+        Raises:
+            RuntimeError: On timeout
+        """
+        with self._condition:
+            generation = self._generation
+            self._count += 1
+            
+            if self._count == self.parties:
+                # Last one to arrive - release all
+                self._count = 0
+                self._generation += 1
+                self._condition.notify_all()
+                return generation
+            else:
+                # Wait for others
+                while generation == self._generation:
+                    if not self._condition.wait(timeout=timeout):
+                        raise RuntimeError(f"Barrier timeout waiting for {self.parties - self._count} more tasks")
+                return generation
+    
+    def reset(self):
+        """Reset the barrier to initial state"""
+        with self._condition:
+            self._count = 0
+            self._generation += 1
+            self._condition.notify_all()
+    
+    def __repr__(self) -> str:
+        return f"Atomic(depth={self._depth}, locked={self.is_locked()})"
+
+
+class ConcurrencyManager:
+    """
+    Central manager for all concurrency operations
+    
+    Manages:
+    - Channel creation and lifecycle
+    - Atomic operation coordination
+    - Goroutine/task scheduling
+    - Deadlock detection
+    - Performance monitoring
+    """
+    
+    def __init__(self):
+        self.channels: Dict[str, Channel] = {}
+        self.atomics: Dict[str, Atomic] = {}
+        self._lock = Lock()
+        self._tasks: List[Any] = []
+        self._completed_count = 0
+    
+    def create_channel(self, name: str, element_type: Optional[str] = None, 
+                       capacity: int = 0) -> Channel:
+        """
+        Create a new channel
+        
+        Args:
+            name: Channel name
+            element_type: Type of elements (for validation)
+            capacity: Buffer capacity (0 = unbuffered)
+            
+        Returns:
+            Created channel
+        """
+        with self._lock:
+            if name in self.channels:
+                raise ValueError(f"Channel '{name}' already exists")
+            
+            channel = Channel(name=name, element_type=element_type, capacity=capacity)
+            self.channels[name] = channel
+            
+            # Debug logging (optional)
+            # from .evaluator.utils import debug_log
+            # debug_log("ConcurrencyManager", f"Created channel: {channel}")
+            
+            return channel
+    
+    def get_channel(self, name: str) -> Optional[Channel]:
+        """Get existing channel by name"""
+        with self._lock:
+            return self.channels.get(name)
+    
+    def create_atomic(self, name: str) -> Atomic:
+        """
+        Create atomic operation region
+        
+        Args:
+            name: Atomic region identifier
+            
+        Returns:
+            Atomic wrapper
+        """
+        with self._lock:
+            if name in self.atomics:
+                return self.atomics[name]
+            
+            atomic = Atomic()
+            self.atomics[name] = atomic
+            
+            # Debug logging (optional)
+            # from .evaluator.utils import debug_log
+            # debug_log("ConcurrencyManager", f"Created atomic: {name}")
+            
+            return atomic
+    
+    def close_all_channels(self):
+        """Close all open channels"""
+        with self._lock:
+            for channel in self.channels.values():
+                if channel.is_open:
+                    channel.close()
+    
+    def statistics(self) -> Dict[str, Any]:
+        """Get concurrency statistics"""
+        with self._lock:
+            open_channels = sum(1 for ch in self.channels.values() if ch.is_open)
+            return {
+                "channels_created": len(self.channels),
+                "channels_open": open_channels,
+                "atomics_created": len(self.atomics),
+                "tasks_total": len(self._tasks),
+                "tasks_completed": self._completed_count
+            }
+    
+    def __repr__(self) -> str:
+        stats = self.statistics()
+        return (f"ConcurrencyManager("
+                f"channels={stats['channels_open']}/{stats['channels_created']}, "
+                f"atomics={stats['atomics_created']}, "
+                f"tasks={stats['tasks_completed']}/{stats['tasks_total']})")
+
+
+# Global singleton instance
+_concurrency_manager: Optional[ConcurrencyManager] = None
+
+
+def get_concurrency_manager() -> ConcurrencyManager:
+    """
+    Get or create the global concurrency manager instance
+    
+    Returns:
+        ConcurrencyManager singleton
+    """
+    global _concurrency_manager
+    if _concurrency_manager is None:
+        _concurrency_manager = ConcurrencyManager()
+    return _concurrency_manager
+
+
+def reset_concurrency_manager():
+    """Reset the global concurrency manager (for testing)"""
+    global _concurrency_manager
+    if _concurrency_manager:
+        _concurrency_manager.close_all_channels()
+    _concurrency_manager = ConcurrencyManager()

package/src/zexus/config.py

@@ -0,0 +1,201 @@
+"""
+Configuration manager for Zexus interpreter.
+Provides per-user persistent config stored at ~/.zexus/config.json
+Exports a `config` singleton with convenient helpers.
+"""
+
+import os
+import json
+from pathlib import Path
+from datetime import datetime, timezone
+
+DEFAULT_CONFIG = {
+    "debug": {
+        "enabled": False,
+        "level": "none",  # none, minimal, full
+        "last_updated": None
+    },
+    "user_preferences": {
+        "show_warnings": True,
+        "color_output": True,
+        "max_output_lines": 1000
+    }
+}
+
+# Backwards-compatible runtime settings expected by earlier modules
+DEFAULT_RUNTIME = {
+    'syntax_style': 'auto',
+    'enable_advanced_parsing': True,
+    'enable_debug_logs': False,
+    'enable_parser_debug': False,  # OPTIMIZATION: Disable parser debug output for speed
+    # Legacy runtime flags expected by older modules
+    'use_hybrid_compiler': True,
+    'fallback_to_interpreter': True,
+    'compiler_line_threshold': 100,
+    'enable_execution_stats': False,
+}
+
+
+class Config:
+    def __init__(self):
+        self.config_dir = Path.home() / ".zexus"
+        self.config_file = self.config_dir / "config.json"
+        self._data = DEFAULT_CONFIG.copy()
+        self._ensure_loaded()
+
+        # ensure runtime defaults exist for backward compatibility
+        self._data.setdefault('runtime', {})
+        for k, v in DEFAULT_RUNTIME.items():
+            self._data['runtime'].setdefault(k, v)
+
+    def _ensure_loaded(self):
+        try:
+            self.config_dir.mkdir(mode=0o700, exist_ok=True)
+            if self.config_file.exists():
+                with open(self.config_file, 'r', encoding='utf-8') as f:
+                    content = json.load(f)
+                    # Merge with defaults to keep compatibility
+                    self._data = self._merge_dicts(DEFAULT_CONFIG, content)
+            else:
+                self._data = DEFAULT_CONFIG.copy()
+                self._write()
+        except Exception:
+            # If anything goes wrong, fall back to defaults in-memory
+            self._data = DEFAULT_CONFIG.copy()
+
+    def _merge_dicts(self, base, override):
+        result = base.copy()
+        for k, v in override.items():
+            if k in result and isinstance(result[k], dict) and isinstance(v, dict):
+                result[k] = self._merge_dicts(result[k], v)
+            else:
+                result[k] = v
+        return result
+
+    def _write(self):
+        try:
+            self.config_dir.mkdir(mode=0o700, exist_ok=True)
+            self._data['debug']['last_updated'] = datetime.now(timezone.utc).isoformat()
+            with open(self.config_file, 'w', encoding='utf-8') as f:
+                json.dump(self._data, f, indent=4)
+        except Exception:
+            # Fail silently; we do not want to crash the interpreter for config issues
+            pass
+
+    # Public API
+    @property
+    def debug_level(self):
+        return self._data.get('debug', {}).get('level', 'none')
+
+    @debug_level.setter
+    def debug_level(self, value):
+        if value not in ('none', 'minimal', 'full'):
+            raise ValueError('Invalid debug level')
+        self._data.setdefault('debug', {})['level'] = value
+        self._data['debug']['enabled'] = (value != 'none')
+        self._write()
+
+    def enable_debug(self, level='full'):
+        self.debug_level = level
+
+    def disable_debug(self):
+        self.debug_level = 'none'
+
+    def is_debug_full(self):
+        return self.debug_level == 'full'
+
+    def is_debug_minimal(self):
+        return self.debug_level == 'minimal'
+
+    def is_debug_none(self):
+        return self.debug_level == 'none'
+
+    # Backwards-compatible properties
+    @property
+    def syntax_style(self):
+        return self._data.get('runtime', {}).get('syntax_style', 'auto')
+
+    @syntax_style.setter
+    def syntax_style(self, value):
+        self._data.setdefault('runtime', {})['syntax_style'] = value
+        self._write()
+
+    @property
+    def enable_advanced_parsing(self):
+        return self._data.get('runtime', {}).get('enable_advanced_parsing', True)
+
+    @enable_advanced_parsing.setter
+    def enable_advanced_parsing(self, value):
+        self._data.setdefault('runtime', {})['enable_advanced_parsing'] = bool(value)
+        self._write()
+
+    @property
+    def enable_debug_logs(self):
+        # Map legacy flag to debug level
+        return self.debug_level != 'none'
+
+    @enable_debug_logs.setter
+    def enable_debug_logs(self, value):
+        if value:
+            if self.debug_level == 'none':
+                self.debug_level = 'minimal'
+        else:
+            self.debug_level = 'none'
+
+    # Legacy runtime properties
+    @property
+    def use_hybrid_compiler(self):
+        return self._data.get('runtime', {}).get('use_hybrid_compiler', True)
+
+    @use_hybrid_compiler.setter
+    def use_hybrid_compiler(self, value):
+        self._data.setdefault('runtime', {})['use_hybrid_compiler'] = bool(value)
+        self._write()
+
+    @property
+    def fallback_to_interpreter(self):
+        return self._data.get('runtime', {}).get('fallback_to_interpreter', True)
+
+    @fallback_to_interpreter.setter
+    def fallback_to_interpreter(self, value):
+        self._data.setdefault('runtime', {})['fallback_to_interpreter'] = bool(value)
+        self._write()
+
+    @property
+    def compiler_line_threshold(self):
+        return int(self._data.get('runtime', {}).get('compiler_line_threshold', 100))
+
+    @compiler_line_threshold.setter
+    def compiler_line_threshold(self, value):
+        try:
+            v = int(value)
+        except Exception:
+            v = 100
+        self._data.setdefault('runtime', {})['compiler_line_threshold'] = v
+        self._write()
+
+    @property
+    def enable_execution_stats(self):
+        return bool(self._data.get('runtime', {}).get('enable_execution_stats', False))
+
+    @enable_execution_stats.setter
+    def enable_execution_stats(self, value):
+        self._data.setdefault('runtime', {})['enable_execution_stats'] = bool(value)
+        self._write()
+
+    # Helper logging function used by modules
+    def should_log(self, level='debug'):
+        """Decide whether to emit a log of a particular level.
+        Levels: 'debug' (very verbose), 'info' (useful info), 'warn', 'error'
+        """
+        dl = self.debug_level
+        if dl == 'full':
+            return True
+        if dl == 'minimal':
+            return level in ('error', 'warn', 'info')
+        # none
+        return level in ('error',)
+
+
+# Singleton
+config = Config()

package/src/zexus/crypto_bridge.py

@@ -0,0 +1,19 @@
+import hashlib
+
+def sha256_hash(data):
+    return hashlib.sha256(data.encode()).hexdigest()
+
+def generate_sphincs_keypair():
+    # Placeholder - will implement real SPHINCS+ later
+    return {
+        "public_key": "sphincs_public_key_placeholder",
+        "private_key": "sphincs_private_key_placeholder" 
+    }
+
+def sphincs_sign(message, private_key):
+    # Placeholder
+    return "sphincs_signature_placeholder"
+
+def sphincs_verify(message, signature, public_key):
+    # Placeholder  
+    return True