zexus 1.8.0 → 1.8.2

package/scripts/postinstall.js

@@ -3,42 +3,225 @@
 const { execSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
+const os = require('os');
 
 console.log('\n🚀 Installing Zexus Programming Language...\n');
 
-// Check if Python is available
-try {
-  const pythonVersion = execSync('python3 --version', { encoding: 'utf-8' });
-  console.log(`✓ Found ${pythonVersion.trim()}`);
-} catch (error) {
-  console.error('❌ Python 3.8+ is required but not found.');
-  console.error('Please install Python 3.8 or higher: https://www.python.org/downloads/');
-  process.exit(1);
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function hasCommand(cmd) {
+  try {
+    execSync(`${cmd} --version`, { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
 }
 
-// Check Python version
-try {
-  const versionCheck = execSync('python3 -c "import sys; sys.exit(0 if sys.version_info >= (3, 8) else 1)"');
-  console.log('✓ Python version is 3.8 or higher');
-} catch (error) {
-  console.error('❌ Python 3.8 or higher is required.');
+function run(cmd, opts = {}) {
+  return execSync(cmd, { encoding: 'utf-8', stdio: 'inherit', ...opts });
+}
+
+function runQuiet(cmd) {
+  return execSync(cmd, { encoding: 'utf-8', stdio: 'pipe' });
+}
+
+const isWin = os.platform() === 'win32';
+const pip = isWin ? 'pip' : 'pip3';
+const python = isWin ? 'python' : 'python3';
+
+// ---------------------------------------------------------------------------
+// 1. Python — check or install
+// ---------------------------------------------------------------------------
+
+let pythonAvailable = false;
+
+if (hasCommand(python)) {
+  try {
+    const ver = runQuiet(`${python} --version`).trim();
+    console.log(`✓ Found ${ver}`);
+    // Verify >= 3.8
+    runQuiet(`${python} -c "import sys; sys.exit(0 if sys.version_info >= (3, 8) else 1)"`);
+    console.log('✓ Python version is 3.8 or higher');
+    pythonAvailable = true;
+  } catch {
+    console.error('❌ Python was found but version is below 3.8.');
+    console.error('   Please upgrade to Python 3.8+: https://www.python.org/downloads/');
+  }
+} else {
+  console.warn('⚠️  python3 not found on PATH.');
+  // Attempt auto-install on common platforms
+  if (os.platform() === 'linux') {
+    console.log('   Attempting to install python3 via apt...');
+    try {
+      run('sudo apt-get update -qq && sudo apt-get install -y -qq python3 python3-pip python3-venv');
+      pythonAvailable = true;
+      console.log('✓ Python 3 installed via apt');
+    } catch {
+      console.warn('   Could not auto-install Python. Please install manually:');
+      console.warn('   https://www.python.org/downloads/');
+    }
+  } else if (os.platform() === 'darwin') {
+    if (hasCommand('brew')) {
+      console.log('   Attempting to install python3 via Homebrew...');
+      try {
+        run('brew install python@3');
+        pythonAvailable = true;
+        console.log('✓ Python 3 installed via Homebrew');
+      } catch {
+        console.warn('   Could not auto-install Python. Please install manually:');
+        console.warn('   https://www.python.org/downloads/');
+      }
+    } else {
+      console.warn('   Please install Python 3.8+: https://www.python.org/downloads/');
+    }
+  } else {
+    console.warn('   Please install Python 3.8+: https://www.python.org/downloads/');
+  }
+}
+
+if (!pythonAvailable) {
+  console.error('\n❌ Python 3.8+ is required but could not be found or installed.');
+  console.error('   Install it from: https://www.python.org/downloads/');
+  console.error('   Then re-run: npm rebuild zexus');
   process.exit(1);
 }
 
-// Install Zexus Python package
+// ---------------------------------------------------------------------------
+// 2. pip — ensure available
+// ---------------------------------------------------------------------------
+
+if (!hasCommand(pip) && !hasCommand('pip')) {
+  console.log('   pip not found — bootstrapping...');
+  try {
+    run(`${python} -m ensurepip --upgrade`);
+  } catch {
+    try {
+      run(`${python} -m pip install --upgrade pip`);
+    } catch {
+      console.warn('⚠️  Could not bootstrap pip. Python package install may fail.');
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// 3. Install Zexus Python package
+// ---------------------------------------------------------------------------
+
 console.log('\n📦 Installing Zexus Python package...');
+
+// Check if zexus is already installed and up-to-date
+let zexusInstalled = false;
 try {
-  execSync('pip3 install zexus', { stdio: 'inherit' });
-  console.log('\n✓ Zexus Python package installed successfully');
-} catch (error) {
-  console.error('\n❌ Failed to install Zexus Python package.');
-  console.error('Please run manually: pip3 install zexus');
-  process.exit(1);
+  runQuiet(`${python} -c "import zexus"`);
+  zexusInstalled = true;
+  console.log('✓ Zexus Python package already installed');
+} catch {
+  // Not installed yet
+}
+
+if (!zexusInstalled) {
+  try {
+    run(`${python} -m pip install --user "zexus[full]"`);
+    console.log('✓ Zexus Python package installed successfully');
+  } catch {
+    // Retry without --user (some environments like venvs don't need it)
+    try {
+      run(`${python} -m pip install "zexus[full]"`);
+      console.log('✓ Zexus Python package installed successfully');
+    } catch {
+      console.error('❌ Failed to install Zexus Python package.');
+      console.error(`   Please run manually: ${python} -m pip install "zexus[full]"`);
+      // Don't exit — commands that don't need Python may still work
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// 4. Rust toolchain — check or install, then build rust_core
+// ---------------------------------------------------------------------------
+
+const pkgRoot = path.resolve(__dirname, '..');
+const cargoToml = path.join(pkgRoot, 'rust_core', 'Cargo.toml');
+
+if (fs.existsSync(cargoToml)) {
+  let cargoReady = hasCommand('cargo');
+
+  if (!cargoReady) {
+    console.log('\n🦀 Rust toolchain (cargo) not found.');
+    console.log('   Attempting to install Rust via rustup...');
+    try {
+      if (isWin) {
+        // On Windows, download and run rustup-init
+        console.log('   Please install Rust manually: https://rustup.rs');
+      } else {
+        // Unix: install rustup non-interactively
+        run('curl --proto "=https" --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y');
+        // Source the cargo env so it's available in this session
+        const cargoEnv = path.join(os.homedir(), '.cargo', 'env');
+        if (fs.existsSync(cargoEnv)) {
+          // Read the cargo bin path and add to PATH for child processes
+          const cargoBin = path.join(os.homedir(), '.cargo', 'bin');
+          process.env.PATH = `${cargoBin}${path.delimiter}${process.env.PATH}`;
+        }
+        cargoReady = hasCommand('cargo');
+        if (cargoReady) {
+          console.log('✓ Rust toolchain installed via rustup');
+        }
+      }
+    } catch (err) {
+      console.warn('⚠️  Could not auto-install Rust. Continuing with pure-Python VM.');
+      console.warn('   To install manually: https://rustup.rs');
+    }
+  } else {
+    console.log('\n✓ Rust toolchain detected');
+  }
+
+  if (cargoReady) {
+    // Check if zexus_core is already importable
+    let rustVmInstalled = false;
+    try {
+      runQuiet(`${python} -c "import zexus_core"`);
+      rustVmInstalled = true;
+      console.log('✓ Rust VM extension (zexus_core) already installed');
+    } catch {
+      // Need to build
+    }
+
+    if (!rustVmInstalled) {
+      console.log('🔨 Building Rust VM extension (zexus_core)...');
+      try {
+        // Ensure maturin is available
+        try {
+          runQuiet(`${python} -m maturin --version`);
+        } catch {
+          console.log('   Installing maturin build tool...');
+          run(`${python} -m pip install --user --upgrade maturin`);
+        }
+        run(`${python} -m maturin develop -m "${cargoToml}" --release`);
+        runQuiet(`${python} -c "import zexus_core"`);
+        console.log('✓ Rust VM extension built and installed');
+      } catch (error) {
+        console.warn('\n⚠️  Rust VM build failed; continuing with pure-Python VM.');
+        console.warn('   To retry manually:');
+        console.warn(`     ${python} -m pip install maturin && ${python} -m maturin develop -m rust_core/Cargo.toml --release`);
+      }
+    }
+  }
+} else {
+  console.log('\nℹ️  rust_core/Cargo.toml not bundled; skipping Rust VM build.');
 }
 
+// ---------------------------------------------------------------------------
+// Done
+// ---------------------------------------------------------------------------
+
 console.log('\n✅ Zexus installed successfully!\n');
 console.log('Get started:');
 console.log('  zexus --help       # Show help');
 console.log('  zx --version       # Check version');
+console.log('  zx run file.zx     # Run a Zexus file');
 console.log('  zexus examples/    # Explore examples\n');
 console.log('Documentation: https://github.com/Zaidux/zexus-interpreter\n');

package/src/zexus/__init__.py

@@ -4,7 +4,7 @@ Zexus Programming Language
 A declarative, intent-based programming language for modern applications.
 """
 
-__version__ = "1.8.0"
+__version__ = "1.8.2"
 __author__ = "Ziver Labs"
 __email__ = "ziverofficial567@gmail.com"
 

package/src/zexus/cli/main.py

@@ -156,7 +156,7 @@ def show_all_commands():
     console.print("\n[bold green]💡 Tip:[/bold green] Use 'zx <command> --help' for detailed command options\n")
 
 @click.group(invoke_without_command=True)
-@click.version_option(version="1.8.0", prog_name="Zexus")
+@click.version_option(version="1.8.2", prog_name="Zexus")
 @click.option('--syntax-style', type=click.Choice(['universal', 'tolerable', 'auto']),
               default='auto', help='Syntax style to use (universal=strict, tolerable=flexible)')
 @click.option('--advanced-parsing', is_flag=True, default=True,

package/src/zexus/cli/zpm.py

@@ -18,7 +18,7 @@ console = Console()
 
 
 @click.group()
-@click.version_option(version="1.8.0", prog_name="ZPM")
+@click.version_option(version="1.8.2", prog_name="ZPM")
 def cli():
     """ZPM - Zexus Package Manager
     

package/src/zexus/evaluator/bytecode_compiler.py

@@ -41,13 +41,26 @@ _SHARED_CACHE: Optional[BytecodeCache] = None
 
 
 def get_shared_cache() -> BytecodeCache:
-    """Get the global shared bytecode cache (persistent across runs)"""
+    """Get the global shared bytecode cache.
+
+    Note: The compiler stores AST objects (e.g., LoadExpression/FindExpression) inside
+    bytecode constants for VM keyword builtins.
+
+    Persisting these bytecodes to disk can cause order-dependent behavior during tests
+    because the same codebase is imported under multiple module namespaces (e.g.
+    `zexus.*` and `src.zexus.*`), producing distinct AST classes that are not
+    interchangeable at runtime.
+    """
     global _SHARED_CACHE
     if _SHARED_CACHE is None:
+        # Default to in-memory only under pytest to avoid cross-test contamination.
+        is_pytest = bool(os.environ.get("PYTEST_CURRENT_TEST"))
+        persist_env = os.environ.get("ZEXUS_BYTECODE_CACHE_PERSISTENT")
+        persist_requested = bool(persist_env) and persist_env.lower() not in ("0", "false", "off")
         _SHARED_CACHE = BytecodeCache(
             max_size=2000,
             max_memory_mb=100,
-            persistent=True,  # Enable disk persistence
+            persistent=(persist_requested and not is_pytest),
             debug=False
         )
     return _SHARED_CACHE
@@ -161,11 +174,6 @@ class EvaluatorBytecodeCompiler:
             cached = self.cache.get(node)
             if cached:
                 return cached
-            
-            # Check pattern cache (similar code structure)
-            pattern_cached = self.cache.get_by_pattern(node)
-            if pattern_cached:
-                return pattern_cached
         
         # Cache miss - compile
         self.builder = BytecodeBuilder()
@@ -184,10 +192,12 @@ class EvaluatorBytecodeCompiler:
             
             bytecode.set_metadata('created_by', 'evaluator')
             
-            # Store in caches
+            # Store in cache
+            # NOTE: Pattern-cache reuse is intentionally disabled here because the current
+            # pattern hashing ignores literal/name fields, which can return bytecode with
+            # incorrect embedded constants/identifiers for “similar” nodes.
             if use_cache and self.cache:
                 self.cache.put(node, bytecode)
-                self.cache.put_by_pattern(node, bytecode)
             
             return bytecode
             
@@ -261,15 +271,51 @@ class EvaluatorBytecodeCompiler:
     
     def _compile_LetStatement(self, node: zexus_ast.LetStatement):
         """Compile let statement"""
-        # Compile the value expression
+        # Support destructuring patterns: let {a, b: x} = expr; let [x, y, ..rest] = expr
+        if isinstance(getattr(node, "name", None), zexus_ast.DestructurePattern):
+            self._compile_node(node.value)
+            pattern = node.name
+            if pattern.kind == 'map':
+                for source_key, target_name in pattern.bindings:
+                    self.builder.emit("DUP")
+                    self.builder.emit_constant(source_key)
+                    self.builder.emit("INDEX")
+                    self.builder.emit_store(target_name)
+                self.builder.emit("POP")
+                return
+            if pattern.kind == 'list':
+                for idx, target_name in pattern.bindings:
+                    self.builder.emit("DUP")
+                    self.builder.emit_constant(idx)
+                    self.builder.emit("INDEX")
+                    self.builder.emit_store(target_name)
+                if pattern.rest:
+                    rest_start = len(pattern.bindings)
+                    self.builder.emit("DUP")
+                    self.builder.emit_constant(rest_start)
+                    self.builder.emit_constant(None)
+                    self.builder.emit("SLICE")
+                    self.builder.emit_store(pattern.rest)
+                self.builder.emit("POP")
+                return
+
+            self.errors.append(f"Unsupported destructure pattern kind: {pattern.kind}")
+            self.builder.emit("POP")
+            return
+
+        # Regular identifier assignment
         self._compile_node(node.value)
-        # Store it
         name = str(node.name.value).strip()
         self.builder.emit_store(name)
     
     def _compile_ConstStatement(self, node: zexus_ast.ConstStatement):
         """Compile const statement"""
-        # Similar to let for now
+        # Const supports the same destructuring patterns as let.
+        if isinstance(getattr(node, "name", None), zexus_ast.DestructurePattern):
+            # Reuse let destructuring behavior
+            fake_let = node
+            return self._compile_LetStatement(fake_let)
+
         self._compile_node(node.value)
         name = str(node.name.value).strip()
         self.builder.emit_store(name)
@@ -283,10 +329,18 @@ class EvaluatorBytecodeCompiler:
         self.builder.emit("RETURN")
     
     def _compile_ContinueStatement(self, node: zexus_ast.ContinueStatement):
-        """Compile continue statement - enables error recovery mode"""
-        # Emit a special instruction or constant to signal continue mode
-        # For now, emit a CONTINUE instruction that the VM can handle
-        self.builder.emit("CONTINUE")
+        """Compile continue statement.
+
+        Behavior (mirrors VM compiler):
+        - Inside a loop: jump to the loop's continue target
+        - Outside a loop: enable continue-on-error mode
+        """
+        if self._loop_stack:
+            continue_label = self._loop_stack[-1].get('continue')
+            if continue_label:
+                self.builder.emit_jump(continue_label)
+                return
+        self.builder.emit("ENABLE_ERROR_MODE")
 
     def _compile_BreakStatement(self, node: zexus_ast.BreakStatement):
         """Compile break statement by jumping to loop end label"""
@@ -350,6 +404,53 @@ class EvaluatorBytecodeCompiler:
 
         # While statements don't return values by default
         self.builder.emit_constant(None)
+
+    def _compile_ForStatement(self, node):
+        """Compile classic for loop (initializer; condition; increment) { body }.
+
+        Note: The core parser currently focuses on for-each loops, but other
+        parsing strategies / legacy ASTs may still produce ForStatement nodes.
+        This keeps the evaluator bytecode compiler aligned with the VM compiler.
+        """
+        start_label = f"for_start_{id(node)}"
+        end_label = f"for_end_{id(node)}"
+        continue_label = start_label if getattr(node, "increment", None) is None else f"for_continue_{id(node)}"
+
+        # Initializer
+        initializer = getattr(node, "initializer", None)
+        if initializer is not None:
+            self._compile_node(initializer)
+
+        # Track loop labels for break/continue
+        self._loop_stack.append({'start': start_label, 'end': end_label, 'continue': continue_label})
+
+        # Condition
+        self.builder.mark_label(start_label)
+        condition = getattr(node, "condition", None)
+        if condition is not None:
+            self._compile_node(condition)
+            self.builder.emit_jump_if_false(end_label)
+
+        # Body
+        body = getattr(node, "body", None)
+        if body is not None:
+            self._compile_node(body)
+
+        # Increment
+        increment = getattr(node, "increment", None)
+        if increment is not None:
+            self.builder.mark_label(continue_label)
+            self._compile_node(increment)
+            self.builder.emit("POP")
+
+        # Jump back to condition
+        self.builder.emit_jump(start_label)
+
+        # End
+        self.builder.mark_label(end_label)
+        self._loop_stack.pop()
+
+        self.builder.emit_constant(None)
     
     def _compile_ForEachStatement(self, node: zexus_ast.ForEachStatement):
         """Compile for-each loop"""
@@ -458,14 +559,18 @@ class EvaluatorBytecodeCompiler:
     
     def _compile_PrintStatement(self, node: zexus_ast.PrintStatement):
         """Compile print statement"""
-        # Compile the value to print
+        # PrintStatement can have value (single) or values (multiple)
+        if hasattr(node, 'values') and node.values:
+            for val in node.values:
+                self._compile_node(val)
+                self.builder.emit("PRINT")
+            return
+
         if hasattr(node, 'value') and node.value:
             self._compile_node(node.value)
         else:
-            # Empty print
             self.builder.emit_constant("")
-        
-        # Emit PRINT opcode
+
         self.builder.emit("PRINT")
 
     def _compile_UseStatement(self, node: zexus_ast.UseStatement):
@@ -547,6 +652,24 @@ class EvaluatorBytecodeCompiler:
     def _compile_PatternStatement(self, node: zexus_ast.PatternStatement):
         """Compile pattern matching directives to VM builtins."""
         self._emit_vm_builtin_call("__vm_pattern_statement__", node, discard_result=False)
+
+    def _compile_ExportStatement(self, node):
+        """Compile export statement - no-op for bytecode.
+        
+        Export is a declaration/annotation; the names being exported
+        are already defined by their own declarations (contract, action, etc.).
+        The evaluator handles export registration at module level.
+        """
+        # Export names are registered by the evaluator, not bytecode
+        pass
+
+    def _compile_EmitStatement(self, node):
+        """Compile emit statement to VM builtin call."""
+        self._emit_vm_builtin_call("__vm_emit_statement__", node, discard_result=False)
+
+    def _compile_ProtocolStatement(self, node):
+        """Compile protocol statement to VM builtin call."""
+        self._emit_vm_builtin_call("__vm_protocol_statement__", node, discard_result=False)
     
     # === Blockchain Statement Compilation ===
     
@@ -582,7 +705,7 @@ class EvaluatorBytecodeCompiler:
         
         # Jump if true (condition passes)
         pass_label = f"require_pass_{id(node)}"
-        self.builder.emit("JUMP_IF_TRUE", None)
+        self.builder.emit_jump_if_true(pass_label)
         
         # Condition failed - revert
         if hasattr(node, 'message') and node.message:
@@ -697,34 +820,8 @@ class EvaluatorBytecodeCompiler:
         # Build map from stack
         self.builder.emit("BUILD_MAP", len(node.pairs))
 
-    def _compile_PropertyAccessExpression(self, node: zexus_ast.PropertyAccessExpression):
-        """Compile property access"""
-        if self.builder is None:
-            return
-        
-        # Compile object
-        self._compile_node(node.object)
-        
-        if node.computed:
-            # Bracket notation: obj[expr]
-            self._compile_node(node.property)
-            self._builder_emit("INDEX")
-        else:
-            # Dot notation: obj.prop
-            if hasattr(node.property, 'value'):
-                name = node.property.value
-            else:
-                name = str(node.property)
-            
-            # Push property name as constant
-            self.builder.emit_constant(name)
-            self._builder_emit("GET_ATTR")
-            
-    def _builder_emit(self, opcode):
-        """Helper to emit opcode string or enum"""
-        # If builder has emit, use it. Some builders might use emit(opcode, operand).
-        # Wrapper to handle potential string usage if enum not fully refreshed
-        self.builder.emit(opcode)
+    # LI12: _compile_PropertyAccessExpression is defined later in this file.
+    # The earlier duplicate implementation was dead code (overridden).
 
     def _compile_InfixExpression(self, node: zexus_ast.InfixExpression):
         """Compile infix expression"""
@@ -1165,7 +1262,8 @@ class EvaluatorBytecodeCompiler:
             elif op == 'OR':
                 return BooleanObj(bool(v1) or bool(v2))
             
-        except:
+        except Exception:
+            # SECURITY (H11): Narrowed from bare except: to Exception
             pass
         
         return None
@@ -1278,7 +1376,7 @@ class EvaluatorBytecodeCompiler:
         # List of supported node types
         supported = {
             'Program', 'ExpressionStatement', 'LetStatement', 'ConstStatement',
-            'ReturnStatement', 'ContinueStatement', 'IfStatement', 'WhileStatement', 'ForEachStatement',
+            'ReturnStatement', 'ContinueStatement', 'IfStatement', 'WhileStatement', 'ForStatement', 'ForEachStatement',
             'BlockStatement', 'ActionStatement', 'FunctionStatement', 'PrintStatement',
             'Identifier', 'IntegerLiteral', 'FloatLiteral',
             'StringLiteral', 'Boolean', 'ListLiteral', 'MapLiteral', 'NullLiteral',
@@ -1386,7 +1484,7 @@ def should_use_vm_for_node(node) -> bool:
     node_type = type(node).__name__
     
     # Always use VM for loops
-    if node_type in ['WhileStatement', 'ForEachStatement']:
+    if node_type in ['WhileStatement', 'ForStatement', 'ForEachStatement']:
         return True
     
     # Use VM for complex functions