zexus 1.8.0 → 1.8.2

package/src/zexus/parser/strategy_context.py

@@ -15,7 +15,9 @@ STATEMENT_STARTERS = {
     STORAGE, AUDIT, RESTRICT, SANDBOX, TRAIL, NATIVE, GC, INLINE, BUFFER,
     SIMD, DEFER, PATTERN, ENUM, STREAM, WATCH, LOG, CAPABILITY, GRANT,
     REVOKE, VALIDATE, SANITIZE, IMMUTABLE, INTERFACE, TYPE_ALIAS, MODULE,
-    PACKAGE, USING, MIDDLEWARE, AUTH, THROTTLE, CACHE, REQUIRE
+    PACKAGE, USING, MIDDLEWARE, AUTH, THROTTLE, CACHE, REQUIRE,
+    EMIT, PROTOCOL, SEAL,
+    CHANNEL, SEND, RECEIVE, ATOMIC, ASYNC,
 }
 
 _MEANINGFUL_TOKEN_TYPES = {
@@ -162,6 +164,10 @@ class ContextStackParser:
             ANIMATION: self._parse_animation_statement,
             CLOCK: self._parse_clock_statement,
             GC: self._parse_gc_statement_block,
+            # EMIT handler
+            EMIT: self._parse_emit_statement_block,
+            # PROTOCOL handler
+            PROTOCOL: self._parse_protocol_statement_block,
         }
 
     def push_context(self, context_type, context_name=None):
@@ -1262,7 +1268,8 @@ class ContextStackParser:
             EXPORT, USE, DEBUG, ENTITY, CONTRACT, AUDIT, RESTRICT, SANDBOX, TRAIL, NATIVE, GC, INLINE,
             BUFFER, SIMD, DEFER, PATTERN, ENUM, STREAM, WATCH, CAPABILITY, GRANT,
             REVOKE, VALIDATE, SANITIZE, IMMUTABLE, INTERFACE, TYPE_ALIAS, MODULE,
-            PACKAGE, USING
+            PACKAGE, USING,
+            CHANNEL, SEND, RECEIVE, ATOMIC, ASYNC,
         }
         j = assign_idx + 1
         nesting_depth = 0
@@ -1558,9 +1565,18 @@ class ContextStackParser:
         except Exception:
             pass
 
-        # 1. Extract Name
+        # 1. Extract Name and optional implements clause
         contract_name = tokens[1].literal if tokens[1].type == IDENT else "UnknownContract"
-        parser_debug(f"  📝 Contract Name: {contract_name}")
+        implements = None
+        
+        # Check for 'implements' keyword: contract Name implements ProtocolName { ... }
+        for idx in range(2, min(len(tokens), 5)):
+            if idx < len(tokens) and tokens[idx].type == IMPLEMENTS:
+                if idx + 1 < len(tokens) and tokens[idx + 1].type == IDENT:
+                    implements = Identifier(tokens[idx + 1].literal)
+                break
+        
+        parser_debug(f"  📝 Contract Name: {contract_name}" + (f" implements {implements}" if implements else ""))
 
         # 2. Identify Block Boundaries
         brace_start = -1
@@ -1935,7 +1951,8 @@ class ContextStackParser:
         contract_stmt = ContractStatement(
             name=Identifier(contract_name),
             body=body_block,
-            modifiers=None
+            modifiers=None,
+            implements=implements
         )
         
         # Add backward compatibility attributes
@@ -3156,6 +3173,67 @@ class ContextStackParser:
                 i = j
                 continue
 
+            elif token.type == EMIT:
+                # Parse EMIT statement: emit EventName(args)
+                j = i + 1
+                emit_tokens = [token]
+                paren_nest = 0
+                
+                # Collect until end of emit statement (close paren or semicolon/newline boundary)
+                while j < len(tokens):
+                    tj = tokens[j]
+                    if tj.type == LPAREN:
+                        paren_nest += 1
+                    elif tj.type == RPAREN:
+                        paren_nest -= 1
+                        if paren_nest == 0:
+                            emit_tokens.append(tj)
+                            j += 1
+                            break
+                    elif tj.type == SEMICOLON and paren_nest == 0:
+                        j += 1
+                        break
+                    emit_tokens.append(tj)
+                    j += 1
+                
+                parser_debug(f"    📝 Found emit statement: {[t.literal for t in emit_tokens]}")
+                
+                block_info = {'tokens': emit_tokens}
+                stmt = self._parse_emit_statement_block(block_info, tokens)
+                if stmt:
+                    statements.append(stmt)
+                
+                i = j
+                continue
+
+            elif token.type == PROTOCOL:
+                # Parse PROTOCOL statement: protocol Name { action method1() ... }
+                j = i + 1
+                proto_tokens = [token]
+                brace_nest = 0
+                
+                while j < len(tokens):
+                    tj = tokens[j]
+                    proto_tokens.append(tj)
+                    if tj.type == LBRACE:
+                        brace_nest += 1
+                    elif tj.type == RBRACE:
+                        brace_nest -= 1
+                        if brace_nest == 0:
+                            j += 1
+                            break
+                    j += 1
+                
+                parser_debug(f"    📝 Found protocol statement: {[t.literal for t in proto_tokens[:10]]}")
+                
+                block_info = {'tokens': proto_tokens}
+                stmt = self._parse_protocol_statement_block(block_info, tokens)
+                if stmt:
+                    statements.append(stmt)
+                
+                i = j
+                continue
+
             elif token.type == WATCH:
                 j = i + 1
                 stmt_tokens = [token]
@@ -3907,6 +3985,35 @@ class ContextStackParser:
                 i = j
                 continue
 
+            elif token.type == CHANNEL:
+                # Parse CHANNEL declaration: channel<type>[capacity] name
+                j = i + 1
+                channel_tokens = [token]
+                # Collect until we hit a statement starter or semicolon at nesting 0
+                nesting = 0
+                while j < len(tokens):
+                    tj = tokens[j]
+                    if tj.type in (LBRACKET, LT):
+                        nesting += 1
+                    elif tj.type in (RBRACKET, GT):
+                        nesting -= 1
+                    elif nesting == 0 and tj.type == SEMICOLON:
+                        j += 1  # skip semicolon
+                        break
+                    elif nesting == 0 and tj.type in statement_starters and len(channel_tokens) > 1:
+                        break
+                    channel_tokens.append(tj)
+                    j += 1
+
+                # Use the context handler to parse the channel tokens
+                block_info = {'tokens': channel_tokens}
+                stmt = self._parse_channel_statement(block_info, tokens)
+                if stmt:
+                    statements.append(stmt)
+
+                i = j
+                continue
+
             elif token.type == ATOMIC:
                 # Parse ATOMIC statement: atomic { statements }
                 j = i + 1
@@ -3939,6 +4046,48 @@ class ContextStackParser:
                 continue
 
             elif token.type == ASYNC:
+                # Check if this is "async action" — treat as action with async modifier
+                if i + 1 < len(tokens) and tokens[i + 1].type == ACTION:
+                    # Collect entire async action declaration including brace body
+                    j = i + 1  # skip to ACTION token
+                    stmt_tokens = [tokens[j]]  # Start with ACTION token
+                    j += 1
+                    brace_nest = 0
+                    paren_nest = 0
+                    while j < len(tokens):
+                        tj = tokens[j]
+                        stmt_tokens.append(tj)
+                        if tj.type == LPAREN:
+                            paren_nest += 1
+                        elif tj.type == RPAREN:
+                            if paren_nest > 0:
+                                paren_nest -= 1
+                        elif tj.type == LBRACE:
+                            brace_nest += 1
+                        elif tj.type == RBRACE:
+                            brace_nest -= 1
+                            if brace_nest == 0:
+                                j += 1
+                                break
+                        j += 1
+
+                    # Parse as action statement and set is_async flag
+                    block_info = {'tokens': stmt_tokens}
+                    stmt = self._parse_action_statement(block_info, tokens)
+                    if stmt:
+                        stmt.is_async = True
+                        try:
+                            existing_modifiers = list(getattr(stmt, 'modifiers', []) or [])
+                            if 'async' not in existing_modifiers:
+                                existing_modifiers.append('async')
+                            stmt.modifiers = existing_modifiers
+                        except Exception:
+                            stmt.modifiers = ['async']
+                        statements.append(stmt)
+
+                    i = j
+                    continue
+
                 # Parse ASYNC expression: async <expression>
                 j = i + 1
                 
@@ -6081,6 +6230,22 @@ class ContextStackParser:
         # If this is "async function", let _parse_function_statement_context handle it
         if len(tokens) > 1 and tokens[1].type == FUNCTION:
             return self._parse_function_statement_context(block_info, all_tokens)
+
+        # If this is "async action", let _parse_action_statement handle it with async flag
+        if len(tokens) > 1 and tokens[1].type == ACTION:
+            action_tokens = tokens[1:]  # Strip ASYNC
+            action_block = {'tokens': action_tokens}
+            stmt = self._parse_action_statement(action_block, all_tokens)
+            if stmt:
+                stmt.is_async = True
+                try:
+                    existing_modifiers = list(getattr(stmt, 'modifiers', []) or [])
+                    if 'async' not in existing_modifiers:
+                        existing_modifiers.append('async')
+                    stmt.modifiers = existing_modifiers
+                except Exception:
+                    stmt.modifiers = ['async']
+            return stmt
         
         # The tokens are [ASYNC, ...expression tokens...]
         # We can just call parse_async_expression from the main parser!
@@ -7667,10 +7832,157 @@ class ContextStackParser:
                 
             parser_debug("  ✅ Watch statement (explicit)")
             return WatchStatement(reaction=reaction, watched_expr=watched_expr)
-            
+
+        # Form 3: watch expr { ... } (expression followed by block, no arrow)
+        brace_idx = -1
+        for i, t in enumerate(tokens):
+            if t.type == LBRACE:
+                brace_idx = i
+                break
+
+        if brace_idx > 1:
+            expr_tokens = tokens[1:brace_idx]
+            reaction_tokens = tokens[brace_idx:]
+            watched_expr = self._parse_expression(expr_tokens)
+            if reaction_tokens and reaction_tokens[0].type == LBRACE:
+                inner = reaction_tokens[1:-1] if reaction_tokens[-1].type == RBRACE else reaction_tokens[1:]
+                stmts = self._parse_block_statements(inner)
+                reaction = BlockStatement()
+                reaction.statements = stmts
+            else:
+                reaction = self._parse_expression(reaction_tokens)
+            parser_debug("  ✅ Watch statement (variable)")
+            return WatchStatement(reaction=reaction, watched_expr=watched_expr)
+
         parser_debug("  ❌ Invalid watch syntax")
         return None
 
+    def _parse_emit_statement_block(self, block_info, all_tokens):
+        """Parse emit statement.
+        
+        Form: emit EventName(arg1, arg2, ...)
+        Example: emit Transfer("0xALICE", "0xBOB", 100)
+        """
+        parser_debug("🔧 [Context] Parsing emit statement")
+        tokens = block_info.get('tokens', [])
+        
+        if not tokens or tokens[0].type != EMIT:
+            parser_debug("  ❌ Expected EMIT keyword")
+            return None
+        
+        # Token 1 should be the event name (IDENT)
+        if len(tokens) < 2 or tokens[1].type != IDENT:
+            parser_debug("  ❌ Expected event name after emit")
+            return None
+        
+        event_name = Identifier(tokens[1].literal)
+        
+        # Parse arguments if present: emit EventName(arg1, arg2)
+        arguments = []
+        if len(tokens) > 2 and tokens[2].type == LPAREN:
+            # Find matching RPAREN
+            paren_depth = 0
+            arg_start = 3
+            for idx in range(2, len(tokens)):
+                if tokens[idx].type == LPAREN:
+                    paren_depth += 1
+                elif tokens[idx].type == RPAREN:
+                    paren_depth -= 1
+                    if paren_depth == 0:
+                        # Parse arguments between parens
+                        arg_tokens = tokens[3:idx]
+                        if arg_tokens:
+                            # Split by commas at depth 0
+                            current_arg = []
+                            inner_depth = 0
+                            for at in arg_tokens:
+                                if at.type == LPAREN:
+                                    inner_depth += 1
+                                elif at.type == RPAREN:
+                                    inner_depth -= 1
+                                if at.type == COMMA and inner_depth == 0:
+                                    if current_arg:
+                                        expr = self._parse_expression(current_arg)
+                                        if expr:
+                                            arguments.append(expr)
+                                        current_arg = []
+                                else:
+                                    current_arg.append(at)
+                            if current_arg:
+                                expr = self._parse_expression(current_arg)
+                                if expr:
+                                    arguments.append(expr)
+                        break
+        
+        parser_debug(f"  ✅ Emit statement: {event_name} with {len(arguments)} args")
+        return EmitStatement(event_name, arguments)
+
+    def _parse_protocol_statement_block(self, block_info, all_tokens):
+        """Parse protocol statement.
+        
+        Form: protocol Name { action method1() action method2(arg) -> type }
+        Example: protocol Greetable { action greet() -> string }
+        """
+        parser_debug("🔧 [Context] Parsing protocol statement")
+        tokens = block_info.get('tokens', [])
+        
+        if not tokens or tokens[0].type != PROTOCOL:
+            parser_debug("  ❌ Expected PROTOCOL keyword")
+            return None
+        
+        # Token 1 should be protocol name
+        if len(tokens) < 2 or tokens[1].type != IDENT:
+            parser_debug("  ❌ Expected protocol name")
+            return None
+        
+        protocol_name = Identifier(tokens[1].literal)
+        
+        # Parse method signatures from brace block
+        methods = []
+        brace_start = -1
+        for idx, t in enumerate(tokens):
+            if t.type == LBRACE:
+                brace_start = idx
+                break
+        
+        if brace_start != -1:
+            # Find matching RBRACE
+            brace_end = len(tokens) - 1
+            for idx in range(len(tokens) - 1, brace_start, -1):
+                if tokens[idx].type == RBRACE:
+                    brace_end = idx
+                    break
+            
+            # Parse inner tokens for method signatures
+            inner = tokens[brace_start + 1:brace_end]
+            i = 0
+            while i < len(inner):
+                t = inner[i]
+                # Look for action/function keyword or bare identifiers as method names
+                if t.type in (ACTION, FUNCTION):
+                    i += 1
+                    if i < len(inner) and inner[i].type == IDENT:
+                        methods.append(inner[i].literal)
+                        # Skip past params and return type
+                        while i < len(inner) and inner[i].type != SEMICOLON and inner[i].type != ACTION and inner[i].type != FUNCTION:
+                            i += 1
+                        if i < len(inner) and inner[i].type == SEMICOLON:
+                            i += 1
+                        continue
+                elif t.type == IDENT:
+                    methods.append(t.literal)
+                    # Skip to next method
+                    i += 1
+                    while i < len(inner) and inner[i].type != SEMICOLON and inner[i].type != ACTION and inner[i].type != FUNCTION:
+                        i += 1
+                    if i < len(inner) and inner[i].type == SEMICOLON:
+                        i += 1
+                    continue
+                i += 1
+        
+        parser_debug(f"  ✅ Protocol statement: {protocol_name} with methods: {methods}")
+        return ProtocolStatement(name=protocol_name, methods=methods)
+
     def _parse_protect_statement(self, block_info, all_tokens):
         """Parse protect statement.
         

package/src/zexus/parser/strategy_structural.py

@@ -46,7 +46,7 @@ class StructuralAnalyzer:
               DEFER, PATTERN, ENUM, STREAM, WATCH, MATCH,
               CAPABILITY, GRANT, REVOKE, VALIDATE, SANITIZE, IMMUTABLE,
               INTERFACE, TYPE_ALIAS, MODULE, PACKAGE, USING,
-              CHANNEL, ATOMIC,
+              CHANNEL, ATOMIC, EMIT, PROTOCOL,
               # Blockchain keywords
               LEDGER, STATE, REQUIRE, REVERT, LIMIT
           }
@@ -1212,7 +1212,7 @@ class StructuralAnalyzer:
               DEFER, PATTERN, ENUM, STREAM, WATCH,
               CAPABILITY, GRANT, REVOKE, VALIDATE, SANITIZE, IMMUTABLE,
               INTERFACE, TYPE_ALIAS, MODULE, PACKAGE, USING,
-              CHANNEL, ATOMIC, ASYNC,  # Added ASYNC to recognize async expressions as statement boundaries
+              CHANNEL, ATOMIC, ASYNC, EMIT, PROTOCOL,
               LBRACE  # Added LBRACE to recognize standalone blocks as statements
           }
 

package/src/zexus/persistence.py

@@ -12,12 +12,21 @@ from threading import Lock
 from typing import Dict, Any, Optional, Set
 from .object import (
     Object, Integer, Float, String, Boolean as BooleanObj, 
-    Null, NULL, List, Map, EntityInstance
+    Null, NULL, List, Map, EntityInstance,
+    _sanitize_identifier
 )
 
 # Storage directory for persistent data
 PERSISTENCE_DIR = os.path.expanduser("~/.zexus/persistence")
-os.makedirs(PERSISTENCE_DIR, exist_ok=True)
+
+
+def _ensure_persistence_dir(path: str = PERSISTENCE_DIR) -> None:
+    """Ensure persistence directory exists.
+
+    MEDIUM (M3): Directory creation is deferred until persistence is actually used
+    to avoid surprising filesystem writes at import time.
+    """
+    os.makedirs(path, exist_ok=True)
 
 
 # ===============================================
@@ -142,8 +151,10 @@ class PersistentStorage:
     
     def __init__(self, scope_id: str, storage_dir: str = PERSISTENCE_DIR,
                  max_items: int = None, max_size_mb: int = None):
-        self.scope_id = scope_id
-        self.db_path = os.path.join(storage_dir, f"{scope_id}.sqlite")
+        _ensure_persistence_dir(storage_dir)
+        # SECURITY (C5): Sanitize scope_id to prevent path traversal
+        self.scope_id = _sanitize_identifier(scope_id, "scope_id")
+        self.db_path = os.path.join(storage_dir, f"{self.scope_id}.sqlite")
         self.conn = None
         self.lock = Lock()
         
@@ -278,10 +289,9 @@ class PersistentStorage:
             
             if row is None:
                 return None
-            
-            
-            # Update usage stats
-            self._update_usage_stats()
+
+            # LI2: Reads should not force a full usage-stats refresh.
+            # Usage is updated on writes/deletes/clear.
             return self._deserialize({'type': row[0], 'value': row[1]})
     
     def delete(self, name: str):
@@ -290,6 +300,7 @@ class PersistentStorage:
             cursor = self.conn.cursor()
             cursor.execute('DELETE FROM variables WHERE name = ?', (name,))
             self.conn.commit()
+            self._update_usage_stats()
     
     def is_const(self, name: str) -> bool:
         """Check if a variable is const"""
@@ -309,12 +320,11 @@ class PersistentStorage:
     def clear(self):
         """Clear all persisted variables"""
         with self.lock:
-            
-            # Update usage stats
-            self._update_usage_stats()
             cursor = self.conn.cursor()
             cursor.execute('DELETE FROM variables')
             self.conn.commit()
+            # LI1: update stats after mutation, not before.
+            self._update_usage_stats()
 
     def _key_to_str(self, key):
         """Convert a Zexus object key to a Python string for JSON serialization."""
@@ -350,11 +360,24 @@ class PersistentStorage:
             return {'type': 'null', 'value': json.dumps(None)}
         elif isinstance(obj, EntityInstance):
             serialized_values = {k: self._serialize(v) for k, v in obj.values.items()}
+
+            # LI3: Preserve entity shape so deserialization can rebuild a usable
+            # EntityDefinition (properties + inheritance layout) even if methods
+            # can't be persisted.
+            prop_names = []
+            try:
+                if hasattr(obj, 'entity_def') and hasattr(obj.entity_def, 'get_all_properties'):
+                    prop_names = list(obj.entity_def.get_all_properties().keys())
+            except Exception:
+                prop_names = []
+            if not prop_names:
+                prop_names = list(serialized_values.keys())
             return {
                 'type': 'entity_instance',
                 'value': json.dumps({
                     'entity_name': obj.entity_def.name,
-                    'values': serialized_values
+                    'values': serialized_values,
+                    'properties': prop_names,
                 })
             }
         else:
@@ -383,15 +406,19 @@ class PersistentStorage:
             pairs = {k: self._deserialize(v) for k, v in value.items()}
             return Map(pairs)
         elif obj_type == 'entity_instance':
-            # Note: This creates a basic EntityInstance without full EntityDefinition
-            # For production, you'd need to store/restore the entity definition
+            # LI3: Rebuild a minimally useful EntityDefinition from persisted
+            # property names. Methods/computed properties are not persisted.
             from .object import EntityDefinition
             entity_name = value['entity_name']
             serialized_values = value['values']
             deserialized_values = {k: self._deserialize(v) for k, v in serialized_values.items()}
-            
-            # Create minimal entity definition
-            entity_def = EntityDefinition(entity_name, [])
+
+            prop_names = value.get('properties') or list(deserialized_values.keys())
+            try:
+                props = {name: {"type": "any", "default_value": NULL} for name in prop_names}
+            except Exception:
+                props = {}
+            entity_def = EntityDefinition(entity_name, props)
             return EntityInstance(entity_def, deserialized_values)
         else:
             return String(str(value))
@@ -499,6 +526,8 @@ def list_persistent_scopes() -> list:
 
 def delete_persistent_scope(scope_name: str):
     """Delete a persistent storage scope"""
+    # SECURITY (C7): Sanitize scope_name to prevent path traversal / arbitrary deletion
+    scope_name = _sanitize_identifier(scope_name, "scope_name")
     db_path = os.path.join(PERSISTENCE_DIR, f"{scope_name}.sqlite")
     if os.path.exists(db_path):
         os.remove(db_path)