zexus 1.6.8 → 1.7.2

package/src/zexus/zexus_ast.py

@@ -2,6 +2,10 @@
 
 # Base classes
 class Node: 
+    # Source location for debugger / error reporting (set by parser)
+    line: int = 0
+    column: int = 0
+
     def __repr__(self):
         return f"{self.__class__.__name__}()"
 
@@ -33,13 +37,16 @@ class ConstStatement(Statement):
     """Const statement - immutable variable declaration
     
     const MAX_VALUE = 100;
+    const PI: float = 3.14;
     """
-    def __init__(self, name, value):
+    def __init__(self, name, value, type_annotation=None):
         self.name = name
         self.value = value
+        self.type_annotation = type_annotation
 
     def __repr__(self):
-        return f"ConstStatement(name={self.name}, value={self.value})"
+        type_str = f", type={self.type_annotation}" if self.type_annotation else ""
+        return f"ConstStatement(name={self.name}, value={self.value}{type_str})"
 
 class DataStatement(Statement):
     """Data statement - dataclass definition
@@ -279,6 +286,53 @@ class ThemeStatement(Statement):
     def __repr__(self):
         return f"ThemeStatement(name={self.name}, properties={self.properties})"
 
+
+class ColorStatement(Statement):
+    def __init__(self, name, value):
+        self.name = name
+        self.value = value  # Expression describing the colour
+
+    def __repr__(self):
+        return f"ColorStatement(name={self.name}, value={self.value})"
+
+
+class CanvasStatement(Statement):
+    def __init__(self, name, properties=None, body=None):
+        self.name = name
+        self.properties = properties  # Optional expression (MapLiteral or Identifier)
+        self.body = body              # Optional BlockStatement with drawing directives
+
+    def __repr__(self):
+        return f"CanvasStatement(name={self.name}, properties={self.properties}, body={self.body})"
+
+
+class GraphicsStatement(Statement):
+    def __init__(self, name, body=None):
+        self.name = name
+        self.body = body  # Optional BlockStatement defining layers/operations
+
+    def __repr__(self):
+        return f"GraphicsStatement(name={self.name}, body={self.body})"
+
+
+class AnimationStatement(Statement):
+    def __init__(self, name, body=None, properties=None):
+        self.name = name
+        self.body = body            # Optional BlockStatement for frame definitions
+        self.properties = properties  # Optional expression (e.g. map literal)
+
+    def __repr__(self):
+        return f"AnimationStatement(name={self.name}, properties={self.properties}, body={self.body})"
+
+
+class ClockStatement(Statement):
+    def __init__(self, name, properties=None):
+        self.name = name
+        self.properties = properties  # Optional expression (map literal or string)
+
+    def __repr__(self):
+        return f"ClockStatement(name={self.name}, properties={self.properties})"
+
 class ActionStatement(Statement):
     def __init__(self, name, parameters, body, is_async=False, return_type=None):
         self.name = name
@@ -339,13 +393,15 @@ class DebugStatement(Statement):
 
 # NEW: Try-catch statement  
 class TryCatchStatement(Statement):
-    def __init__(self, try_block, error_variable, catch_block):
+    def __init__(self, try_block, error_variable, catch_block, finally_block=None):
         self.try_block = try_block
         self.error_variable = error_variable
         self.catch_block = catch_block
+        self.finally_block = finally_block
 
     def __repr__(self):
-        return f"TryCatchStatement(error_var={self.error_variable})"
+        has_finally = " +finally" if self.finally_block else ""
+        return f"TryCatchStatement(error_var={self.error_variable}{has_finally})"
 
 # NEW: External function declaration
 class ExternalDeclaration(Statement):
@@ -417,11 +473,13 @@ class TrailStatement(Statement):
 
 # Expression Nodes
 class Identifier(Expression):
-    def __init__(self, value): 
+    def __init__(self, value, type_annotation=None): 
         self.value = value
+        self.type_annotation = type_annotation  # Optional[str] for typed parameters
 
     def __repr__(self):
-        return f"Identifier('{self.value}')"
+        type_str = f": {self.type_annotation}" if self.type_annotation else ""
+        return f"Identifier('{self.value}{type_str}')"
     
     def __str__(self):
         return self.value
@@ -450,6 +508,19 @@ class StringLiteral(Expression):
     def __str__(self):
         return self.value
 
+class StringInterpolationExpression(Expression):
+    """String interpolation: "hello ${name}, you are ${age} years old"
+    
+    parts is a list of (type, value) where type is "str" or "expr".
+    For "str" parts, value is a string literal.
+    For "expr" parts, value is a parsed Expression AST node.
+    """
+    def __init__(self, parts):
+        self.parts = parts  # list of ("str", string) or ("expr", Expression)
+    
+    def __repr__(self):
+        return f"StringInterpolation({len(self.parts)} parts)"
+
 class Boolean(Expression):
     def __init__(self, value): 
         self.value = value
@@ -472,6 +543,25 @@ class ThisExpression(Expression):
         return "ThisExpression()"
 
 
+class DestructurePattern(Expression):
+    """Destructuring pattern for let/const assignments.
+    
+    kind='map':  let {a, b} = expr  or  let {a: x, b: y} = expr
+    kind='list': let [x, y, z] = expr
+    
+    bindings: list of (source_key, target_name) tuples
+      - map:  [("a", "a"), ("b", "renamed")] for {a, b: renamed}
+      - list: [(0, "x"), (1, "y")] for [x, y]
+    rest: optional name for rest element (..rest)
+    """
+    def __init__(self, kind, bindings, rest=None):
+        self.kind = kind          # 'map' or 'list'
+        self.bindings = bindings  # list of (source, target_name_str)
+        self.rest = rest          # optional rest variable name
+
+    def __repr__(self):
+        return f"DestructurePattern(kind={self.kind}, bindings={len(self.bindings)}, rest={self.rest})"
+
 class ListLiteral(Expression):
     def __init__(self, elements): 
         self.elements = elements
@@ -600,6 +690,17 @@ class PropertyAccessExpression(Expression):
     def __repr__(self):
         return f"PropertyAccessExpression(object={self.object}, property={self.property}, computed={self.computed})"
 
+
+class SliceExpression(Expression):
+    """Slice expression: obj[start:end]"""
+    def __init__(self, object, start=None, end=None):
+        self.object = object
+        self.start = start
+        self.end = end
+
+    def __repr__(self):
+        return f"SliceExpression(object={self.object}, start={self.start}, end={self.end})"
+
 class AssignmentExpression(Expression):
     def __init__(self, name, value):
         self.name = name
@@ -621,6 +722,33 @@ class AwaitExpression(Expression):
     def __repr__(self):
         return f"AwaitExpression(expression={self.expression})"
 
+
+class FindExpression(Expression):
+    def __init__(self, target, scope=None):
+        self.target = target
+        self.scope = scope
+
+    def __repr__(self):
+        parts = [f"target={self.target}"]
+        if self.scope is not None:
+            parts.append(f"scope={self.scope}")
+        return f"FindExpression({', '.join(parts)})"
+
+
+class LoadExpression(Expression):
+    def __init__(self, target, source=None, provider_hint=None):
+        self.target = target
+        self.source = source
+        self.provider_hint = provider_hint
+
+    def __repr__(self):
+        parts = [f"target={self.target}"]
+        if self.source is not None:
+            parts.append(f"source={self.source}")
+        if self.provider_hint:
+            parts.append(f"provider_hint={self.provider_hint}")
+        return f"LoadExpression({', '.join(parts)})"
+
 class FileImportExpression(Expression):
     """File import expression for << operator
     
@@ -1089,9 +1217,6 @@ class WatchStatement(Statement):
     def __repr__(self):
         return f"WatchStatement(expr={self.watched_expr}, reaction={self.reaction})"
 
-    def __repr__(self):
-        return f"WatchStatement(watch={self.watched_expr})"
-
 
 class LogStatement(Statement):
     """Log statement - Redirect output to file
@@ -1500,12 +1625,13 @@ class StateStatement(Statement):
     state owner = TX.caller;
     state locked = false;
     """
-    def __init__(self, name, initial_value=None):
+    def __init__(self, name, initial_value=None, modifiers=None):
         self.name = name  # Identifier: state variable name
         self.initial_value = initial_value  # Optional Expression: initial value
+        self.modifiers = modifiers or []  # List[str]: modifiers (private, public, etc.)
 
     def __repr__(self):
-        return f"StateStatement(name={self.name}, initial={self.initial_value})"
+        return f"StateStatement(name={self.name}, initial={self.initial_value}, modifiers={self.modifiers})"
 
 
 class ContractStatement(Statement):

package/src/zexus/zexus_token.py

@@ -32,6 +32,16 @@ OR = "||"
 QUESTION = "?"          # Ternary operator: condition ? true_val : false_val
 NULLISH = "??"          # Nullish coalescing: value ?? default
 
+# Compound Assignment Operators
+PLUS_ASSIGN = "+="      # Addition assignment: x += 5
+MINUS_ASSIGN = "-="     # Subtraction assignment: x -= 5
+STAR_ASSIGN = "*="      # Multiplication assignment: x *= 5
+SLASH_ASSIGN = "/="     # Division assignment: x /= 5
+MOD_ASSIGN = "%="       # Modulo assignment: x %= 5
+POWER = "**"            # Exponentiation: x ** 2
+POWER_ASSIGN = "**="    # Exponentiation assignment: x **= 2
+INTERP_STRING = "INTERP_STRING"  # String interpolation: "hello ${name}"
+
 # Delimiters
 COMMA = ","
 SEMICOLON = ";"
@@ -78,6 +88,8 @@ CLOCK = "CLOCK"
 MAP = "MAP"
 WHILE = "WHILE"
 USE = "USE"
+FIND = "FIND"
+LOAD = "LOAD"
 EXACTLY = "EXACTLY"
 EMBEDDED = "EMBEDDED"
 EXPORT = "EXPORT"
@@ -85,11 +97,13 @@ LAMBDA = "LAMBDA"
 DEBUG = "DEBUG"      # NEW: Debug token
 TRY = "TRY"          # NEW: Try token
 CATCH = "CATCH"      # NEW: Catch token
+FINALLY = "FINALLY"  # NEW: Finally token
 CONTINUE = "CONTINUE" # NEW: Continue on error token
 BREAK = "BREAK"      # NEW: Break loop statement
 THROW = "THROW"      # NEW: Throw error statement
 EXTERNAL = "EXTERNAL" # NEW: From token
 FROM = "FROM"        # NEW: From token
+AS = "AS"
 
 # ASYNC / AWAIT / MODULE / EVENT / ENUM / PROTOCOL tokens
 ASYNC = "ASYNC"
@@ -174,7 +188,6 @@ LIMIT = "LIMIT"                # Gas/resource limit: action transfer() limit 100
 GAS = "GAS"                    # Gas tracking: gas_used(), gas_remaining()
 PERSISTENT = "PERSISTENT"
 STORAGE = "STORAGE"
-REQUIRE = "REQUIRE"
 
 # PERFORMANCE OPTIMIZATION TOKENS
 NATIVE = "NATIVE"            # Call C/C++ code: native { "func_name", arg1, arg2 }
@@ -187,9 +200,10 @@ SIMD = "SIMD"                # Vector operations: simd(operation, vector1, vecto
 DEFER = "DEFER"              # Cleanup code execution: defer cleanup_code;
 PATTERN = "PATTERN"          # Pattern matching: pattern value { case x => ...; }
 MATCH = "MATCH"              # Match expression: match value { Point(x, y) => ... }
+CASE = "CASE"                # Case clause in match/pattern
+DEFAULT = "DEFAULT"          # Default case in match
 
 # ADVANCED FEATURES TOKENS
-ENUM = "ENUM"                # Type-safe enumerations: enum Color { Red, Green, Blue }
 STREAM = "STREAM"            # Event streaming: stream name as event => handler;
 WATCH = "WATCH"              # Reactive state management: watch variable => reaction;
 LOG = "LOG"                  # Output logging: log > filename.txt
@@ -198,9 +212,6 @@ LOG = "LOG"                  # Output logging: log > filename.txt
 PUBLIC = "PUBLIC"
 PRIVATE = "PRIVATE"
 SEALED = "SEALED"
-ASYNC = "ASYNC"
-NATIVE = "NATIVE"
-INLINE = "INLINE"
 SECURE = "SECURE"
 PURE = "PURE"
 VIEW = "VIEW"                  # View function (alias for pure, read-only)

package/src/zexus/zpm/installer.py

@@ -4,6 +4,7 @@ Package Installer - Handles package installation and dependencies
 import os
 import json
 import shutil
+import tarfile
 from pathlib import Path
 from typing import Dict, Optional
 
@@ -11,9 +12,10 @@ from typing import Dict, Optional
 class PackageInstaller:
     """Handles package installation"""
     
-    def __init__(self, install_dir: Path):
+    def __init__(self, install_dir: Path, registry=None):
         self.install_dir = Path(install_dir)
         self.install_dir.mkdir(parents=True, exist_ok=True)
+        self.registry = registry  # PackageRegistry for tarball downloads
     
     def install(self, package_info: Dict) -> bool:
         """Install a package"""
@@ -40,14 +42,12 @@ class PackageInstaller:
         if pkg_type == "builtin":
             self._install_builtin(name, version, target_dir)
         else:
-            # TODO: Download and extract package
             self._install_from_source(package_info, target_dir)
         
         return True
     
     def _install_builtin(self, name: str, version: str, target_dir: Path):
         """Install a built-in package"""
-        # Create package.json
         pkg_json = {
             "name": name,
             "version": version,
@@ -58,7 +58,6 @@ class PackageInstaller:
         with open(target_dir / "zexus.json", "w") as f:
             json.dump(pkg_json, f, indent=2)
         
-        # Create stub main file
         main_file = target_dir / "index.zx"
         main_file.write_text(f"""// {name} - Built-in Zexus package
 // Version: {version}
@@ -72,23 +71,64 @@ export {{
 """)
     
     def _install_from_source(self, package_info: Dict, target_dir: Path):
-        """Install package from source/tarball"""
-        # TODO: Implement actual download and extraction
-        
-        # For now, create placeholder
+        """Install package from a remote tarball or local path.
+
+        If the package metadata contains a ``tarball`` key pointing to a
+        local file, that tarball is extracted directly.  Otherwise the
+        installer attempts to download the tarball from the registry via
+        ``registry.download_tarball(name, version)``.
+        """
+        name = package_info["name"]
+        version = package_info["version"]
+
+        # 1. Check for a local tarball path in the metadata
+        tarball_path = package_info.get("tarball")
+        if tarball_path and os.path.isfile(tarball_path):
+            self._extract_tarball(Path(tarball_path), target_dir, name)
+            return
+
+        # 2. Try to download from the remote registry
+        if self.registry is not None:
+            downloaded = self.registry.download_tarball(name, version)
+            if downloaded and downloaded.exists():
+                print(f"📦 Downloaded {name}@{version}")
+                self._extract_tarball(downloaded, target_dir, name)
+                return
+
+        # 3. Fallback — create placeholder with metadata
+        print(f"⚠️  Could not download {name}@{version} — creating placeholder")
         pkg_json = {
-            "name": package_info["name"],
-            "version": package_info["version"],
+            "name": name,
+            "version": version,
             "description": package_info.get("description", ""),
         }
-        
         with open(target_dir / "zexus.json", "w") as f:
             json.dump(pkg_json, f, indent=2)
-        
         main_file = target_dir / "index.zx"
-        main_file.write_text(f"""// {package_info['name']}
-// Placeholder - package installation from remote sources not yet implemented
-""")
+        main_file.write_text(f'// {name}@{version} — placeholder (tarball not available)\n')
+
+    @staticmethod
+    def _extract_tarball(tarball_path: Path, target_dir: Path, package_name: str):
+        """Extract a ``.tar.gz`` tarball into *target_dir*.
+
+        Tarballs created by ``PackagePublisher`` contain files under a
+        ``<package_name>/`` prefix.  We strip that prefix so the files
+        land directly in *target_dir*.
+        """
+        with tarfile.open(tarball_path, "r:gz") as tar:
+            # Security: filter out absolute paths and ..'s
+            safe_members = []
+            prefix = f"{package_name}/"
+            for member in tar.getmembers():
+                if member.name.startswith("/") or ".." in member.name:
+                    continue
+                # Strip the package-name prefix from the archive path
+                if member.name.startswith(prefix):
+                    member.name = member.name[len(prefix):]
+                elif member.name == package_name:
+                    continue  # skip the bare directory entry
+                safe_members.append(member)
+            tar.extractall(path=target_dir, members=safe_members)
     
     def uninstall(self, package: str) -> bool:
         """Uninstall a package"""

package/src/zexus/zpm/package_manager.py

@@ -23,7 +23,7 @@ class PackageManager:
         self.installer = PackageInstaller(self.zpm_dir)
         self.publisher = PackagePublisher(self.registry)
         
-    def init(self, name: str = None, version: str = "1.6.8") -> Dict:
+    def init(self, name: str = None, version: str = "1.7.2") -> Dict:
         """Initialize a new Zexus project with package.json"""
         if self.config_file.exists():
             print(f"⚠️  {self.config_file} already exists")