zexus 1.6.2

package/src/zexus/cli/zpm.py

@@ -0,0 +1,203 @@
+#!/usr/bin/env python3
+"""
+ZPM - Zexus Package Manager CLI
+"""
+import click
+import sys
+from pathlib import Path
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+
+# Add src to path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from zexus.zpm import PackageManager
+
+console = Console()
+
+
+@click.group()
+@click.version_option(version="1.6.2", prog_name="ZPM")
+def cli():
+    """ZPM - Zexus Package Manager
+    
+    Manage packages for your Zexus projects.
+    """
+    pass
+
+
+@cli.command()
+@click.option('--name', '-n', help='Package name')
+@click.option('--version', '-v', default='1.5.0', help='Initial version')
+def init(name, version):
+    """Initialize a new Zexus project"""
+    pm = PackageManager()
+    config = pm.init(name=name, version=version)
+    
+    console.print(Panel.fit(
+        f"[bold green]Project initialized![/bold green]\n\n"
+        f"📦 Name: {config['name']}\n"
+        f"🏷️  Version: {config['version']}\n"
+        f"📄 Config: zexus.json",
+        title="ZPM",
+        border_style="green"
+    ))
+
+
+@cli.command()
+@click.argument('package', required=False)
+@click.option('--dev', '-D', is_flag=True, help='Save to devDependencies')
+@click.option('--save', '-S', is_flag=True, default=True, help='Save to dependencies')
+def install(package, dev, save):
+    """Install a package or all packages from zexus.json
+    
+    Examples:
+        zpm install              # Install all dependencies
+        zpm install std          # Install std package
+        zpm install web@0.2.0    # Install specific version
+        zpm install crypto -D    # Install as dev dependency
+    """
+    pm = PackageManager()
+    
+    if package:
+        success = pm.install(package, dev=dev)
+    else:
+        success = pm.install_all()
+    
+    if not success:
+        sys.exit(1)
+
+
+@cli.command()
+@click.argument('package')
+def uninstall(package):
+    """Uninstall a package
+    
+    Example:
+        zpm uninstall std
+    """
+    pm = PackageManager()
+    success = pm.uninstall(package)
+    
+    if not success:
+        sys.exit(1)
+
+
+@cli.command(name='list')
+def list_packages():
+    """List installed packages"""
+    pm = PackageManager()
+    packages = pm.list()
+    
+    if not packages:
+        console.print("📦 No packages installed")
+        return
+    
+    table = Table(title=f"Installed Packages ({len(packages)})")
+    table.add_column("Name", style="cyan")
+    table.add_column("Version", style="green")
+    table.add_column("Path", style="dim")
+    
+    for pkg in packages:
+        table.add_row(pkg["name"], pkg["version"], pkg["path"])
+    
+    console.print(table)
+
+
+@cli.command()
+@click.argument('query')
+def search(query):
+    """Search for packages
+    
+    Example:
+        zpm search crypto
+    """
+    pm = PackageManager()
+    results = pm.search(query)
+    
+    if not results:
+        console.print(f"🔍 No packages found for '{query}'")
+        return
+    
+    table = Table(title=f"Search Results for '{query}'")
+    table.add_column("Name", style="cyan")
+    table.add_column("Version", style="green")
+    table.add_column("Description", style="white")
+    
+    for pkg in results:
+        table.add_row(
+            pkg["name"],
+            pkg["version"],
+            pkg.get("description", "")
+        )
+    
+    console.print(table)
+
+
+@cli.command()
+def publish():
+    """Publish package to registry
+    
+    Publishes the current package to the ZPM registry.
+    Requires a valid zexus.json with name and version.
+    """
+    pm = PackageManager()
+    success = pm.publish()
+    
+    if not success:
+        sys.exit(1)
+
+
+@cli.command()
+def info():
+    """Show project information"""
+    pm = PackageManager()
+    config = pm.load_config()
+    
+    if not config:
+        console.print("❌ No zexus.json found. Run 'zpm init' first.")
+        sys.exit(1)
+    
+    console.print(Panel.fit(
+        f"[bold cyan]Project Information[/bold cyan]\n\n"
+        f"📦 Name: {config.get('name', 'N/A')}\n"
+        f"🏷️  Version: {config.get('version', 'N/A')}\n"
+        f"📝 Description: {config.get('description', 'N/A')}\n"
+        f"👤 Author: {config.get('author', 'N/A')}\n"
+        f"📜 License: {config.get('license', 'N/A')}\n"
+        f"📄 Main: {config.get('main', 'N/A')}",
+        title="ZPM Info",
+        border_style="cyan"
+    ))
+    
+    # Show dependencies
+    deps = config.get('dependencies', {})
+    if deps:
+        console.print("\n[bold]Dependencies:[/bold]")
+        for name, version in deps.items():
+            console.print(f"  • {name}@{version}")
+    
+    dev_deps = config.get('devDependencies', {})
+    if dev_deps:
+        console.print("\n[bold]Dev Dependencies:[/bold]")
+        for name, version in dev_deps.items():
+            console.print(f"  • {name}@{version}")
+
+
+@cli.command()
+def clean():
+    """Remove zpm_modules directory"""
+    pm = PackageManager()
+    
+    if not pm.zpm_dir.exists():
+        console.print("✅ Already clean (no zpm_modules)")
+        return
+    
+    import shutil
+    shutil.rmtree(pm.zpm_dir)
+    console.print(f"✅ Removed {pm.zpm_dir}")
+
+
+if __name__ == '__main__':
+    cli()

package/src/zexus/compare_interpreter_compiler.py

@@ -0,0 +1,146 @@
+"""Compare top-level symbols between the interpreter (`evaluator/`) and
+the compiler package (`src/zexus/compiler`) and print a simple report.
+
+This script is intentionally conservative: it only considers top-level
+FunctionDef, ClassDef, Assign/AnnAssign targets and simple name exports.
+It helps quickly discover API surface differences so we can decide what the
+compiler lacks compared to the interpreter.
+"""
+import ast
+import os
+import sys
+
+
+def collect_top_level_symbols(path):
+    """Return a set of top-level symbol names defined in the Python file at path."""
+    symbols = set()
+    try:
+        with open(path, 'r', encoding='utf-8') as f:
+            src = f.read()
+    except Exception as e:
+        print(f"ERROR: could not read {path}: {e}")
+        return symbols
+
+    try:
+        tree = ast.parse(src, filename=path)
+    except SyntaxError as e:
+        print(f"ERROR: could not parse {path}: {e}")
+        return symbols
+
+    for node in tree.body:
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+            symbols.add(node.name)
+        elif isinstance(node, ast.Assign):
+            for target in node.targets:
+                if isinstance(target, ast.Name):
+                    symbols.add(target.id)
+                elif isinstance(target, ast.Tuple):
+                    for elt in target.elts:
+                        if isinstance(elt, ast.Name):
+                            symbols.add(elt.id)
+        elif isinstance(node, ast.AnnAssign):
+            target = node.target
+            if isinstance(target, ast.Name):
+                symbols.add(target.id)
+    return symbols
+
+
+def collect_package_symbols(dirpath):
+    """Walk dirpath and collect top-level symbols from all .py files."""
+    pkg_symbols = {}
+    for root, dirs, files in os.walk(dirpath):
+        for fn in files:
+            if not fn.endswith('.py'):
+                continue
+            if fn.startswith('__') and fn.endswith('.py'):
+                # still include __init__ possibly
+                pass
+            full = os.path.join(root, fn)
+            rel = os.path.relpath(full, dirpath)
+            pkg_symbols[rel] = collect_top_level_symbols(full)
+    return pkg_symbols
+
+
+def main():
+    repo_root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..'))
+    
+    # OLD: interp_path = os.path.join(repo_root, 'src', 'zexus', 'evaluator.py')
+    # NEW: interp_path is now the directory
+    interp_dir = os.path.join(repo_root, 'src', 'zexus', 'evaluator') 
+    compiler_dir = os.path.join(repo_root, 'src', 'zexus', 'compiler')
+
+    # Update the check to look for the directory instead of a file
+    if not os.path.isdir(interp_dir):
+        print('Interpreter directory not found:', interp_dir)
+        # Try to look for evaluator modules (Your provided check for directory content)
+        evaluator_files = []
+        if os.path.isdir(interp_dir):
+            evaluator_files = [os.path.join(interp_dir, f) for f in os.listdir(interp_dir) 
+                              if f.endswith('.py') and not f.startswith('__')]
+            if evaluator_files:
+                print('Found evaluator modules:', evaluator_files)
+        sys.exit(2)
+        
+    if not os.path.isdir(compiler_dir):
+        print('Compiler directory not found:', compiler_dir)
+        sys.exit(2)
+
+    # Collect symbols from the interpreter package
+    interp_pkg = collect_package_symbols(interp_dir)
+
+    # Collect symbols from the compiler package
+    compiler_pkg = collect_package_symbols(compiler_dir)
+
+    # union all interpreter symbols
+    interp_symbols_union = set()
+    for fn, syms in interp_pkg.items():
+        interp_symbols_union.update(syms)
+
+    # union all compiler symbols
+    compiler_symbols_union = set()
+    for fn, syms in compiler_pkg.items():
+        compiler_symbols_union.update(syms)
+
+    only_in_interp = sorted(interp_symbols_union - compiler_symbols_union)
+    only_in_compiler = sorted(compiler_symbols_union - interp_symbols_union)
+    common = sorted(interp_symbols_union & compiler_symbols_union)
+
+    print('\nComparison report: interpreter package vs compiler package')
+    print('Interpreter package dir:', interp_dir)
+    print('Compiler package dir:', compiler_dir)
+    print('\nCounts:')
+    print('  interpreter union symbols:', len(interp_symbols_union))
+    print('  compiler union symbols:', len(compiler_symbols_union))
+    print('\nOnly in interpreter ({}):'.format(len(only_in_interp)))
+    for name in only_in_interp:
+        print('   -', name)
+
+    print('\nOnly in compiler ({}):'.format(len(only_in_compiler)))
+    for name in only_in_compiler[:200]:
+        print('   -', name)
+
+    print('\nCommon symbols ({}):'.format(len(common)))
+    for name in common[:200]:
+        print('   -', name)
+        
+    print('\nPer-file interpreter symbol breakdown:')
+    for fn, syms in sorted(interp_pkg.items()):
+        print(f'  {fn}: {len(syms)} symbols')
+
+    print('\nPer-file compiler symbol breakdown:')
+    for fn, syms in sorted(compiler_pkg.items()):
+        print(f'  {fn}: {len(syms)} symbols')
+
+    # Quick hints
+    if only_in_interp:
+        print("""
+HINT: The interpreter package defines top-level symbols that are not present in the compiler package.
+Start by inspecting the names listed above to decide which functionality should be implemented
+or refactored into the compiler. This tool is conservative (top-level only) and may miss
+runtime/exported symbols. For a deeper comparison we can compare call-sites, used imports,
+or run tests that exercise both codepaths.
+""")
+
+
+if __name__ == '__main__':
+    main()

package/src/zexus/compiler/__init__.py

@@ -0,0 +1,169 @@
+# src/zexus/compiler/__init__.py
+
+"""
+Zexus Compiler Phase - Frontend compilation with semantic analysis
+"""
+
+# Minimal top-level exports to avoid import-time cycles/errors.
+# Do not import .parser, .semantic, .bytecode at module import time unconditionally.
+# They will be imported lazily inside ZexusCompiler.compile().
+
+Parser = None  # will be set if parser import succeeds below (best-effort)
+ZexusCompiler = None  # defined below
+
+# UPDATED: Get builtins from evaluator.functions module
+try:
+    from ..evaluator.functions import FunctionEvaluatorMixin
+    # Create instance and get builtins
+    fe = FunctionEvaluatorMixin()
+    fe.__init__()  # Initialize to register builtins
+    BUILTINS = fe.builtins
+except Exception as e:
+    print(f"⚠️  Could not import builtins from evaluator: {e}")
+    BUILTINS = {}
+
+# Try to import ProductionParser now but don't fail if it errors (best-effort).
+try:
+    from .parser import ProductionParser as _ProductionParser
+    Parser = _ProductionParser
+except Exception:
+    # Leave Parser as None; consumers should handle None and provide helpful messages.
+    Parser = None
+
+# --- Compiler class (lazy imports inside compile) --------------------------------
+class ZexusCompiler:
+    def __init__(self, source, enable_optimizations=True):
+        self.source = source
+        self.enable_optimizations = enable_optimizations
+        self.ast = None
+        self.bytecode = None
+        self.errors = []
+        self.analyzer = None  # store SemanticAnalyzer instance after compile
+
+    def compile(self):
+        """Full compilation pipeline with enhanced error reporting (lazy module imports)"""
+        # Import frontend components lazily to avoid import-time circular issues.
+        try:
+            from .lexer import Lexer
+        except Exception as e:
+            self.errors.append(f"Compilation import error (lexer): {e}")
+            return None
+
+        try:
+            from .parser import ProductionParser
+        # if parser import fails, record the error and provide a helpful fallback
+        except Exception as e:
+            self.errors.append(f"Compilation import error (parser): {e}")
+            return None
+
+        try:
+            from .semantic import SemanticAnalyzer
+        except Exception as e:
+            self.errors.append(f"Compilation import error (semantic): {e}")
+            return None
+
+        try:
+            from .bytecode import BytecodeGenerator
+        except Exception as e:
+            self.errors.append(f"Compilation import error (bytecode): {e}")
+            return None
+
+        try:
+            # Phase 1: Lexical Analysis
+            lexer = Lexer(self.source)
+
+            # Phase 2: Syntax Analysis
+            parser = ProductionParser(lexer)
+            self.ast = parser.parse_program()
+            # propagate parser errors
+            if getattr(parser, "errors", None):
+                self.errors.extend(parser.errors)
+
+            if self.errors:
+                return None
+
+            # Phase 3: Semantic Analysis
+            analyzer = SemanticAnalyzer()
+            self.analyzer = analyzer
+
+            # Best-effort: inject BUILTINS into analyzer environment
+            try:
+                if BUILTINS:
+                    if hasattr(analyzer, "register_builtins") and callable(getattr(analyzer, "register_builtins")):
+                        analyzer.register_builtins(BUILTINS)
+                    elif hasattr(analyzer, "environment"):
+                        env = getattr(analyzer, "environment")
+                        # env could be Environment object with set(), or a plain dict
+                        if hasattr(env, "set") and callable(getattr(env, "set")):
+                            for k, v in BUILTINS.items():
+                                try:
+                                    env.set(k, v)
+                                except Exception:
+                                    # best-effort injection — non-fatal
+                                    pass
+                        elif isinstance(env, dict):
+                            for k, v in BUILTINS.items():
+                                env.setdefault(k, v)
+            except Exception:
+                pass
+
+            semantic_errors = analyzer.analyze(self.ast)
+            if semantic_errors:
+                self.errors.extend(semantic_errors)
+
+            if self.errors:
+                return None
+
+            # Phase 4: Bytecode Generation
+            generator = BytecodeGenerator()
+            self.bytecode = generator.generate(self.ast)
+
+            return self.bytecode
+
+        except Exception as e:
+            self.errors.append(f"Compilation error: {str(e)}")
+            return None
+
+    # NEW: run compiled bytecode using small VM
+    def run_bytecode(self, debug=False):
+        """Execute the compiled bytecode ops using the small VM.
+        Requires compile() to have been called successfully (self.bytecode set).
+        Returns VM execution result or None."""
+        if not self.bytecode:
+            self.errors.append("No bytecode to run")
+            return None
+        try:
+            # Lazy import VM to avoid cycles
+            from ..vm.vm import VM
+        except Exception as e:
+            self.errors.append(f"VM import error: {e}")
+            return None
+
+        # Provide builtins mapping to VM if analyzer has environment dict or via compiler BUILTINS
+        builtins_map = {}
+        if self.analyzer and hasattr(self.analyzer, "environment") and isinstance(self.analyzer.environment, dict):
+            builtins_map = {k: v for k, v in self.analyzer.environment.items() if k in BUILTINS}
+        else:
+            # fallback to compiler.BUILTINS (may be dict)
+            try:
+                builtins_map = BUILTINS if isinstance(BUILTINS, dict) else {}
+            except Exception:
+                builtins_map = {}
+
+        # environment mapping passed to VM (start from analyzer.environment if dict)
+        vm_env = {}
+        if self.analyzer and hasattr(self.analyzer, "environment") and isinstance(self.analyzer.environment, dict):
+            vm_env.update(self.analyzer.environment)
+
+        vm = VM(builtins=builtins_map, env=vm_env)
+        return vm.execute(self.bytecode, debug=debug)
+
+# Provide Parser alias for external code expecting it (best-effort)
+try:
+    from .parser import ProductionParser as _ParserAlias
+    Parser = _ParserAlias
+except Exception:
+    # keep existing Parser (possibly None) and avoid raising on import
+    pass
+
+Parser = Parser or None