zexus 1.6.8 → 1.7.2

package/src/zexus/cli/main.py

@@ -3,26 +3,83 @@ import click
 import sys
 import os
 from pathlib import Path
-from rich.console import Console
-from rich.syntax import Syntax
-from rich.panel import Panel
-from rich.table import Table
+
+try:  # Optional rich dependency for colorful CLI output
+    from rich.console import Console
+    from rich.syntax import Syntax
+    from rich.panel import Panel
+    from rich.table import Table
+    _RICH_AVAILABLE = True
+except ModuleNotFoundError:  # Fallback to minimal console utilities when rich is missing
+    _RICH_AVAILABLE = False
+
+    class Console:  # pragma: no cover - straightforward fallback
+        def print(self, *args, **kwargs):
+            sep = kwargs.get("sep", " ")
+            end = kwargs.get("end", "\n")
+            text = sep.join(str(arg) for arg in args)
+            sys.stdout.write(text)
+            if end is not None:
+                sys.stdout.write(end)
+
+        def rule(self, title=""):
+            line = "-" * 40
+            if title:
+                line = f"{line} {title} {line}"
+            self.print(line)
+
+    class Syntax:  # pragma: no cover - fallback keeps interface compatible
+        def __init__(self, code, *_args, **_kwargs):
+            self.code = code
+
+        def __str__(self):
+            return self.code
+
+    class Panel:  # pragma: no cover
+        def __init__(self, renderable, title=None):
+            self.renderable = renderable
+            self.title = title
+
+        def __str__(self):
+            if self.title:
+                return f"[{self.title}] {self.renderable}"
+            return str(self.renderable)
+
+    class Table:  # pragma: no cover
+        def __init__(self, **_kwargs):
+            self.columns = []
+            self.rows = []
+
+        def add_column(self, header, **_kwargs):
+            self.columns.append(header)
+
+        def add_row(self, *columns):
+            self.rows.append(columns)
+
+        def __str__(self):
+            lines = []
+            if self.columns:
+                lines.append(" | ".join(self.columns))
+            for row in self.rows:
+                lines.append(" | ".join(str(col) for col in row))
+            return "\n".join(lines)
 
 # Import your existing modules - UPDATED IMPORTS
 from ..lexer import Lexer
 from ..parser import Parser
 # UPDATED: Import evaluate from evaluator package
-from ..evaluator import evaluate
+from ..evaluator import evaluate, Evaluator
 # UPDATED: Import Environment and String from object module
 from ..object import Environment, String
 from ..syntax_validator import SyntaxValidator
 from ..hybrid_orchestrator import orchestrator
 from ..config import config
+from ..runtime.file_flags import parse_file_flags, apply_vm_config
 # Import error handling
 from ..error_reporter import get_error_reporter, ZexusError, print_error
 # VM and Compiler for high-performance execution
 from ..vm.vm import VM, VMMode
-from ..vm.compiler import compile_ast_to_bytecode
+from ..vm.compiler import compile_ast_to_bytecode, UnsupportedNodeError
 
 console = Console()
 
@@ -36,6 +93,7 @@ def show_all_commands():
     
     commands = [
         ("zx run <file>", "Execute a Zexus program"),
+        ("zx -r \"<code>\"", "Run inline Zexus code (like python -c)"),
         ("zx run --zexus", "Show this command list"),
         ("zx check <file>", "Check syntax with detailed validation"),
         ("zx validate <file>", "Validate and auto-fix syntax errors"),
@@ -50,7 +108,9 @@ def show_all_commands():
         ("--syntax-style=<style>", "universal, tolerable, or auto (default)"),
         ("--execution-mode=<mode>", "interpreter, compiler, or auto (default)"),
         ("--advanced-parsing", "Enable multi-strategy parsing (default: on)"),
-        ("--debug", "Enable debug output"),
+        ("--debug <on|off|minimal|full>", "Enable/disable debug output"),
+        ("--no-debug", "Disable debug output"),
+        ("--no-vm", "Disable VM execution for run"),
         ("--version", "Show Zexus version"),
         ("--help", "Show detailed help"),
         ("", ""),
@@ -66,6 +126,8 @@ def show_all_commands():
         ("zx check --debug program.zx", "Check syntax with debug info"),
         ("zx profile myapp.zx", "Profile with memory tracking"),
         ("zx profile --no-memory --top 10 app.zx", "Profile without memory, show top 10"),
+        ("zx -r \"print(42)\"", "Execute inline code directly"),
+        ("zx -r \"let x = 10; print(x * 2)\"", "Run multi-statement inline code"),
         ("", ""),
         ("[bold]Built-in Functions:[/bold]", "100+ functions available"),
         ("", "Memory: persist_set, persist_get, track_memory"),
@@ -94,54 +156,189 @@ 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.6.8", prog_name="Zexus")
+@click.version_option(version="1.7.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,
               help='Enable advanced multi-strategy parsing (recommended)')
 @click.option('--execution-mode', type=click.Choice(['interpreter', 'compiler', 'auto']),
               default='auto', help='Execution engine to use')
-@click.option('--debug', is_flag=True, help='Enable debug logging')
+@click.option('--debug', type=click.Choice(['on', 'off', 'minimal', 'full', 'none']),
+              help='Enable/disable debug logging (on/off/minimal/full)')
+@click.option('--no-debug', is_flag=True, help='Disable debug logging')
 @click.option('--zexus', is_flag=True, help='Show all available Zexus commands')
+@click.option('-r', '--run-code', type=str, default=None,
+              help='Execute inline Zexus code (like python -c)')
 @click.pass_context
-def cli(ctx, syntax_style, advanced_parsing, execution_mode, debug, zexus):
+def cli(ctx, syntax_style, advanced_parsing, execution_mode, debug, no_debug, zexus, run_code):
     """Zexus Programming Language - Hybrid Interpreter/Compiler
     
     Use 'zx run --zexus' or 'zx --zexus' to see all available commands.
+    Use 'zx -r "<code>"' to execute inline Zexus code.
     """
     
     if zexus:
         show_all_commands()
         sys.exit(0)
     
-    # If no command provided, show help
-    if ctx.invoked_subcommand is None:
-        click.echo(ctx.get_help())
-        return
-    
     ctx.ensure_object(dict)
     ctx.obj['SYNTAX_STYLE'] = syntax_style
     ctx.obj['ADVANCED_PARSING'] = advanced_parsing
     ctx.obj['EXECUTION_MODE'] = execution_mode
-    ctx.obj['DEBUG'] = debug
+    ctx.obj['DEBUG'] = False
     
     # Update config based on CLI flags
-    if debug:
+    if no_debug or debug in ('off', 'none'):
+        config.disable_debug()
+        config.enable_debug_logs = False
+        ctx.obj['DEBUG'] = False
+    elif debug in ('on', 'full'):
+        config.enable_debug('full')
         config.enable_debug_logs = True
+        ctx.obj['DEBUG'] = True
+    elif debug == 'minimal':
+        config.enable_debug('minimal')
+        config.enable_debug_logs = True
+        ctx.obj['DEBUG'] = True
+
+    # Handle inline code execution: zx -r "<code>"
+    if run_code is not None:
+        _execute_inline_code(ctx, run_code)
+        return
+
+    # If no command provided, show help
+    if ctx.invoked_subcommand is None:
+        click.echo(ctx.get_help())
+        return
     if execution_mode == 'compiler':
         config.use_hybrid_compiler = True
     elif execution_mode == 'interpreter':
         config.use_hybrid_compiler = False
 
+
+def _execute_inline_code(ctx, source_code):
+    """Execute inline Zexus code passed via -r flag.
+    
+    Examples:
+        zx -r "print(42)"
+        zx -r "let x = 10; print(x * 2)"
+        zx -r "action greet(name) { print(\"Hello \" + name) }; greet(\"World\")"
+    """
+    error_reporter = get_error_reporter()
+
+    try:
+        # Register source for error reporting
+        error_reporter.register_source("<inline>", source_code)
+
+        syntax_style = ctx.obj['SYNTAX_STYLE']
+        advanced_parsing = ctx.obj['ADVANCED_PARSING']
+        debug_mode = ctx.obj.get('DEBUG', False)
+        validator = SyntaxValidator()
+
+        # Auto-detect syntax style if needed
+        if syntax_style == 'auto':
+            syntax_style = validator.suggest_syntax_style(source_code)
+
+        # Parse the program
+        lexer = Lexer(source_code, filename="<inline>")
+        parser = Parser(lexer, syntax_style, enable_advanced_strategies=advanced_parsing)
+        program = parser.parse_program()
+
+        if parser.errors and any("critical" in e.lower() for e in parser.errors):
+            console.print("[bold red]❌ Parse error in inline code:[/bold red]")
+            for error in parser.errors:
+                console.print(f"  ❌ {error}")
+            sys.exit(1)
+
+        # Set up environment
+        env = Environment()
+        env.set("__file__", String("<inline>"))
+        env.set("__FILE__", String("<inline>"))
+        env.set("__MODULE__", String("__main__"))
+        env.set("__DIR__", String(os.getcwd()))
+
+        from ..object import List as ZList
+        env.set("__ARGS__", ZList([]))
+        env.set("__ARGV__", ZList([]))
+        env.set("__PACKAGE__", String(""))
+
+        # Attempt VM execution first, fall back to interpreter
+        bytecode = None
+        fallback_reason = None
+
+        try:
+            bytecode = compile_ast_to_bytecode(program, optimize=True)
+        except UnsupportedNodeError as e:
+            fallback_reason = str(e)
+        except Exception as e:
+            fallback_reason = str(e)
+
+        if bytecode is not None and fallback_reason is None:
+            vm = VM(
+                mode=VMMode.AUTO,
+                use_jit=True,
+                max_heap_mb=512,
+                debug=debug_mode,
+                gas_limit=10000000
+            )
+            # Load builtins into VM
+            try:
+                builtin_evaluator = Evaluator(use_vm=False)
+                vm.builtins.update(dict(builtin_evaluator.builtins))
+            except Exception:
+                pass
+
+            vm.env["__file__"] = "<inline>"
+            vm.env["__FILE__"] = "<inline>"
+            vm.env["__MODULE__"] = "__main__"
+            vm.env["__DIR__"] = os.getcwd()
+            vm.env["__ARGS__"] = ()
+            vm.env["__ARGV__"] = ()
+            vm.env["__PACKAGE__"] = ""
+
+            try:
+                result = vm.execute(bytecode, debug=debug_mode)
+            except Exception as e:
+                if debug_mode:
+                    import traceback
+                    traceback.print_exc()
+                fallback_reason = str(e)
+
+        if fallback_reason is not None:
+            result = evaluate(program, env, debug_mode=debug_mode, use_vm=False)
+        elif bytecode is None:
+            result = evaluate(program, env, debug_mode=debug_mode, use_vm=False)
+
+        # Print result if meaningful
+        if result and hasattr(result, 'inspect') and result.inspect() != 'null':
+            console.print(result.inspect())
+        elif isinstance(result, str) and result:
+            console.print(result)
+        elif hasattr(result, 'value') and result.value is not None:
+            console.print(str(result.value))
+
+    except ZexusError as e:
+        print_error(e)
+        sys.exit(1)
+    except Exception as e:
+        console.print(f"[bold red]Error:[/bold red] {str(e)}")
+        if ctx.obj.get('DEBUG'):
+            import traceback
+            traceback.print_exc()
+        sys.exit(1)
+
+
 @cli.command()
 @click.argument('file', type=click.Path(exists=True))
 @click.argument('args', nargs=-1)  # Accept any number of additional arguments
-@click.option('--use-vm', is_flag=True, default=True, help='Use VM for execution (default: enabled for performance)')
+@click.option('--use-vm/--no-vm', default=True, help='Use VM for execution (default: enabled for performance)')
 @click.option('--vm-mode', type=click.Choice(['auto', 'stack', 'register', 'parallel']),
               default='auto', help='VM execution mode (auto=best performance)')
 @click.option('--no-optimize', is_flag=True, default=False, help='Disable bytecode optimizations')
+@click.option('--precompile-modules', is_flag=True, default=False,
+              help='Pre-parse and cache all imported modules before execution')
 @click.pass_context
-def run(ctx, file, args, use_vm, vm_mode, no_optimize):
+def run(ctx, file, args, use_vm, vm_mode, no_optimize, precompile_modules):
     """Run a Zexus program with hybrid execution"""
     # Register source for error reporting
     error_reporter = get_error_reporter()
@@ -152,6 +349,37 @@ def run(ctx, file, args, use_vm, vm_mode, no_optimize):
         
         # Register source with error reporter
         error_reporter.register_source(file, source_code)
+
+        # Apply in-file execution flags (if any)
+        file_flags = parse_file_flags(source_code)
+        vm_config = {}
+        if file_flags:
+            if 'use_vm' in file_flags:
+                use_vm = bool(file_flags.get('use_vm'))
+            if 'vm_mode' in file_flags:
+                vm_mode = str(file_flags.get('vm_mode')).lower()
+            if 'no_optimize' in file_flags:
+                no_optimize = bool(file_flags.get('no_optimize'))
+            if 'precompile_modules' in file_flags:
+                precompile_modules = bool(file_flags.get('precompile_modules'))
+            if 'syntax_style' in file_flags:
+                ctx.obj['SYNTAX_STYLE'] = str(file_flags.get('syntax_style'))
+            if 'advanced_parsing' in file_flags:
+                ctx.obj['ADVANCED_PARSING'] = bool(file_flags.get('advanced_parsing'))
+            if 'execution_mode' in file_flags:
+                ctx.obj['EXECUTION_MODE'] = str(file_flags.get('execution_mode'))
+            if 'debug' in file_flags:
+                dbg = file_flags.get('debug')
+                if isinstance(dbg, str):
+                    config.debug_level = dbg
+                    ctx.obj['DEBUG'] = dbg != 'none'
+                else:
+                    ctx.obj['DEBUG'] = bool(dbg)
+                    config.enable_debug_logs = ctx.obj['DEBUG']
+            if 'vm_config' in file_flags and isinstance(file_flags.get('vm_config'), dict):
+                vm_config = dict(file_flags.get('vm_config'))
+
+            console.print("[dim]Applied file flags (@zexus) overrides[/dim]")
         
         syntax_style = ctx.obj['SYNTAX_STYLE']
         advanced_parsing = ctx.obj['ADVANCED_PARSING']
@@ -200,7 +428,36 @@ def run(ctx, file, args, use_vm, vm_mode, no_optimize):
             for error in parser.errors:
                 console.print(f"  ❌ {error}")
             sys.exit(1)
-        
+
+        # Pre-compile imported modules (parse + optional bytecode) before execution
+        if precompile_modules:
+            console.print("[dim]Pre-compiling imported modules...[/dim]", end="")
+            try:
+                from ..module_cache import precompile_modules as _precompile
+                import os as _os
+                _abs = _os.path.abspath(file)
+                precompiled = _precompile(program, _abs, compile_bytecode=use_vm)
+                if precompiled:
+                    console.print(f" [green]done[/green] ({len(precompiled)} module(s) cached)")
+                else:
+                    console.print(" [green]done[/green] (no external modules)")
+            except Exception as e:
+                console.print(f" [yellow]warning:[/yellow] {e}")
+
+        # Static type checking pass
+        try:
+            from ..type_checker import StaticTypeChecker
+            _tc = StaticTypeChecker()
+            _type_diags = _tc.check(program)
+            if _type_diags:
+                for _d in _type_diags:
+                    if _d.level == "error":
+                        console.print(f"  [bold red]✗ {_d}[/bold red]")
+                    else:
+                        console.print(f"  [yellow]⚠ {_d}[/yellow]")
+        except Exception:
+            pass  # type checker should never block execution
+
         # Use the evaluator package
         env = Environment()
         
@@ -231,6 +488,14 @@ def run(ctx, file, args, use_vm, vm_mode, no_optimize):
         env.set("__PACKAGE__", package_name)
         
         # Execute based on mode
+        if not use_vm:
+            try:
+                env.disable_vm = True
+            except Exception:
+                pass
+        bytecode = None
+        fallback_reason = None
+
         if use_vm:
             # VM EXECUTION PATH (High Performance)
             console.print("[dim]Compiling to bytecode...[/dim]", end="")
@@ -238,32 +503,59 @@ def run(ctx, file, args, use_vm, vm_mode, no_optimize):
                 bytecode = compile_ast_to_bytecode(program, optimize=not no_optimize)
                 console.print(" [green]done[/green]")
                 console.print(f"[dim]Bytecode: {len(bytecode.instructions)} instructions, {len(bytecode.constants)} constants[/dim]")
+            except UnsupportedNodeError as e:
+                console.print(" [yellow]unsupported[/yellow]")
+                console.print(f"[bold yellow]⚠️  VM fallback:[/bold yellow] {e}")
+                if ctx.obj.get('DEBUG'):
+                    import traceback
+                    traceback.print_exc()
+                fallback_reason = str(e)
             except Exception as e:
-                console.print(f" [red]failed[/red]")
+                console.print(" [red]failed[/red]")
                 console.print(f"[bold red]Bytecode compilation error:[/bold red] {str(e)}")
                 if ctx.obj.get('DEBUG'):
                     import traceback
                     traceback.print_exc()
-                sys.exit(1)
-            
-            # Initialize VM
-            vm_mode_enum = {
+                fallback_reason = str(e)
+
+        if bytecode is not None and fallback_reason is None:
+            vm_mode_map = {
                 'auto': VMMode.AUTO,
                 'stack': VMMode.STACK,
                 'register': VMMode.REGISTER,
                 'parallel': VMMode.PARALLEL
-            }[vm_mode]
-            
+            }
+            vm_mode_value = vm_mode if vm_mode in vm_mode_map else 'auto'
+            vm_mode_enum = vm_mode_map[vm_mode_value]
+
+            vm_builtins = {}
+            try:
+                builtin_evaluator = Evaluator(use_vm=False)
+                vm_builtins = dict(builtin_evaluator.builtins)
+            except Exception:
+                vm_builtins = {}
+
             console.print(f"[dim]Initializing VM ({vm_mode} mode)...[/dim]", end="")
             vm = VM(
                 mode=vm_mode_enum,
                 use_jit=not no_optimize,
                 max_heap_mb=1000,  # 1GB heap limit
-                debug=ctx.obj.get('DEBUG', False)
+                debug=ctx.obj.get('DEBUG', False),
+                gas_limit=100000000  # 100M instructions for heavy checks
             )
+            if vm_builtins:
+                vm.builtins.update(vm_builtins)
+            apply_vm_config(vm, vm_config)
+            # Mirror interpreter module context for relative imports in VM
+            vm.env["__file__"] = abs_file
+            vm.env["__FILE__"] = abs_file
+            vm.env["__MODULE__"] = "__main__"
+            vm.env["__DIR__"] = os.path.dirname(abs_file)
+            vm.env["__ARGS__"] = args
+            vm.env["__ARGV__"] = args
+            vm.env["__PACKAGE__"] = package_name.value if hasattr(package_name, "value") else package_name
             console.print(" [green]done[/green]")
-            
-            # Execute on VM
+
             console.print("[dim]Executing on VM...[/dim]")
             try:
                 result = vm.execute(bytecode, debug=ctx.obj.get('DEBUG', False))
@@ -272,10 +564,14 @@ def run(ctx, file, args, use_vm, vm_mode, no_optimize):
                 if ctx.obj.get('DEBUG'):
                     import traceback
                     traceback.print_exc()
-                sys.exit(1)
-        else:
-            # INTERPRETER EXECUTION PATH (Standard)
-            result = evaluate(program, env, debug_mode=ctx.obj['DEBUG'])
+                fallback_reason = str(e)
+
+        if fallback_reason is not None:
+            console.print("[bold yellow]🔄 Falling back to interpreter execution...[/bold yellow]")
+            result = evaluate(program, env, debug_mode=ctx.obj['DEBUG'], use_vm=False)
+        elif bytecode is None:
+            # No bytecode generated but VM not requested or compile skipped
+            result = evaluate(program, env, debug_mode=ctx.obj['DEBUG'], use_vm=False)
         
         if result and hasattr(result, 'inspect') and result.inspect() != 'null':
             console.print(f"\n✅ [bold green]Result:[/bold green] {result.inspect()}")
@@ -359,6 +655,59 @@ def check(ctx, file):
         console.print(f"[bold red]Error:[/bold red] {str(e)}")
         sys.exit(1)
 
+
+@cli.command()
+@click.argument('file', type=click.Path(exists=True))
+@click.option('--target', '-t', type=click.Choice(['wasm']), default='wasm',
+              help='Compilation target (default: wasm)')
+@click.option('-o', '--output', type=click.Path(), default=None,
+              help='Output file path (default: <input>.wasm)')
+@click.pass_context
+def compile(ctx, file, target, output):
+    """Compile a Zexus file to a target format (e.g. WebAssembly)."""
+    import os
+    try:
+        with open(file, 'r') as f:
+            source_code = f.read()
+
+        syntax_style = ctx.obj['SYNTAX_STYLE']
+        advanced_parsing = ctx.obj['ADVANCED_PARSING']
+
+        lexer = Lexer(source_code)
+        parser = Parser(lexer, syntax_style, enable_advanced_strategies=advanced_parsing)
+        program = parser.parse_program()
+
+        if parser.errors:
+            console.print("[bold red]❌ Parse errors — cannot compile:[/bold red]")
+            for err in parser.errors:
+                console.print(f"  🚫 {err}")
+            sys.exit(1)
+
+        # Compile AST → bytecode
+        from ..vm.compiler import BytecodeCompiler as BCCompiler
+        bc_compiler = BCCompiler()
+        bytecode = bc_compiler.compile(program)
+
+        if target == 'wasm':
+            from ..vm.wasm_compiler import WasmCompiler
+            wasm = WasmCompiler().compile(bytecode)
+
+            out_path = output or os.path.splitext(file)[0] + '.wasm'
+            with open(out_path, 'wb') as wf:
+                wf.write(wasm)
+
+            console.print(f"[bold green]✅ Compiled to WASM:[/bold green] {out_path} ({len(wasm)} bytes)")
+        else:
+            console.print(f"[bold red]Unknown target: {target}[/bold red]")
+            sys.exit(1)
+
+    except Exception as e:
+        console.print(f"[bold red]Compile error:[/bold red] {str(e)}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)
+
+
 @cli.command()
 @click.argument('file', type=click.Path(exists=True))
 @click.pass_context

package/src/zexus/cli/zpm.py

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