shell-lite 0.4.3__py3-none-any.whl → 0.4.4__py3-none-any.whl

shell_lite/interpreter_final.py

@@ -1,1773 +0,0 @@
-from typing import Any, Dict, List, Callable
-from .ast_nodes import *
-from .lexer_new import Token, Lexer
-from .parser_new import Parser
-import importlib
-import operator
-import re
-import os
-import sys
-import subprocess
-import json
-import math
-import time
-import random
-import urllib.request
-import urllib.parse
-import shutil
-import functools
-from datetime import datetime
-import threading
-import concurrent.futures
-import tkinter as tk
-from tkinter import messagebox, simpledialog
-from http.server import HTTPServer, BaseHTTPRequestHandler
-import csv
-import zipfile
-from datetime import timedelta
-import calendar
-import sqlite3
-try:
-    import keyboard
-    import mouse
-    import pyperclip
-    from plyer import notification
-except ImportError:
-    pass 
-class Environment:
-    def __init__(self, parent=None):
-        self.variables: Dict[str, Any] = {}
-        self.constants: set = set()  
-        self.parent = parent
-    def get(self, name: str) -> Any:
-        if name in self.variables:
-            return self.variables[name]
-        if self.parent:
-            return self.parent.get(name)
-        raise NameError(f"Variable '{name}' is not defined.")
-    def set(self, name: str, value: Any):
-        if name in self.constants:
-            raise RuntimeError(f"Cannot reassign constant '{name}'")
-        if self.parent and name in self.parent.constants:
-            raise RuntimeError(f"Cannot reassign constant '{name}'")
-        self.variables[name] = value
-    def set_const(self, name: str, value: Any):
-        if name in self.variables:
-            raise RuntimeError(f"Constant '{name}' already declared")
-        self.variables[name] = value
-        self.constants.add(name)
-class ReturnException(Exception):
-    def __init__(self, value):
-        self.value = value
-class StopException(Exception):
-    pass
-class SkipException(Exception):
-    pass
-class ShellLiteError(Exception):
-    def __init__(self, message):
-        self.message = message
-        super().__init__(message)
-class LambdaFunction:
-    def __init__(self, params: List[str], body, interpreter):
-        self.params = params
-        self.body = body
-        self.interpreter = interpreter
-        self.closure_env = interpreter.current_env
-    def __call__(self, *args):
-        if len(args) != len(self.params):
-            raise TypeError(f"Lambda expects {len(self.params)} args, got {len(args)}")
-        old_env = self.interpreter.current_env
-        new_env = Environment(parent=self.closure_env)
-        for param, arg in zip(self.params, args):
-            new_env.set(param, arg)
-        self.interpreter.current_env = new_env
-        try:
-            result = self.interpreter.visit(self.body)
-        finally:
-            self.interpreter.current_env = old_env
-        return result
-class Instance:
-    def __init__(self, class_def: ClassDef):
-        self.class_def = class_def
-        self.data: Dict[str, Any] = {}
-class Tag:
-    def __init__(self, name: str, attrs: Dict[str, Any] = None):
-        self.name = name
-        self.attrs = attrs or {}
-        self.children: List[Any] = []
-    def add(self, child):
-        if isinstance(child, Tag):
-             if any(c is child for c in self.children):
-                 return
-        self.children.append(child)
-    def __str__(self):
-        attr_str = ""
-        for k, v in self.attrs.items():
-            attr_str += f' {k}="{v}"'
-        inner = ""
-        for child in self.children:
-            inner += str(child)
-        if self.name in ('img', 'br', 'hr', 'input', 'meta', 'link'):
-            return f"<{self.name}{attr_str} />"
-        return f"<{self.name}{attr_str}>{inner}</{self.name}>"
-class WebBuilder:
-    def __init__(self, interpreter):
-        self.stack: List[Tag] = []
-        self.interpreter = interpreter
-    def push(self, tag: Tag):
-        if self.stack:
-            self.stack[-1].add(tag)
-        self.stack.append(tag)
-    def pop(self):
-        if not self.stack: return None
-        return self.stack.pop()
-    def add_text(self, text: str):
-        if self.stack:
-            self.stack[-1].add(text)
-        else:
-            pass
-class Interpreter:
-    def __init__(self):
-        print('DEBUG: VERSION 2 LOADED')
-        self.global_env = Environment()
-        self.global_env.set('str', str)
-        self.global_env.set('int', int)
-        self.global_env.set('float', float)
-        self.global_env.set('list', list)
-        self.global_env.set('len', len)
-        self.global_env.set('input', input)
-        self.global_env.set('range', range)
-        
-        # English-like helpers
-        self.global_env.set('wait', time.sleep)
-        self.global_env.set('append', lambda l, x: l.append(x))
-        self.global_env.set('remove', lambda l, x: l.remove(x))
-        self.global_env.set('empty', lambda l: len(l) == 0)
-        self.global_env.set('contains', lambda l, x: x in l)
-        
-        self.current_env = self.global_env
-        self.functions: Dict[str, FunctionDef] = {}
-        self.classes: Dict[str, ClassDef] = {}
-        self.http_routes = [] 
-        self.middleware_routes = [] 
-        self.static_routes = {} 
-        self.web = WebBuilder(self)
-        self.db_conn = None
-        self.builtins = {
-            'str': str, 'int': int, 'float': float, 'bool': bool,
-            'list': list, 'len': len,
-            'range': lambda *args: list(range(*args)),
-            'typeof': lambda x: type(x).__name__,
-            'run': self.builtin_run,
-            'read': self.builtin_read,
-            'write': self.builtin_write,
-            'json_parse': self.builtin_json_parse,
-            'json_stringify': self.builtin_json_stringify,
-            'print': print,
-            'abs': abs, 'min': min, 'max': max,
-            'round': round, 'pow': pow, 'sum': sum,
-            'split': lambda s, d=" ": s.split(d),
-            'join': lambda lst, d="": d.join(str(x) for x in lst),
-            'replace': lambda s, old, new: s.replace(old, new),
-            'upper': self._builtin_upper,
-            'lower': lambda s: s.lower(),
-            'trim': lambda s: s.strip(),
-            'startswith': lambda s, p: s.startswith(p),
-            'endswith': lambda s, p: s.endswith(p),
-            'sum_range': self._builtin_sum_range,
-            'range_list': self._builtin_range_list,
-            'find': lambda s, sub: s.find(sub),
-            'char': chr, 'ord': ord,
-            'append': lambda l, x: (l.append(x), l)[1],
-            'push': self._builtin_push,
-            'count': len,  
-            'remove': lambda l, x: l.remove(x),
-            'pop': lambda l, idx=-1: l.pop(idx),
-            'get': lambda l, idx: l[idx],
-            'set': lambda l, idx, val: l.__setitem__(idx, val) or l,
-            'sort': lambda l: sorted(l),
-            'reverse': lambda l: list(reversed(l)),
-            'slice': lambda l, start, end=None: l[start:end],
-            'contains': lambda l, x: x in l,
-            'index': lambda l, x: l.index(x) if x in l else -1,
-            'exists': os.path.exists,
-            'delete': os.remove,
-            'copy': shutil.copy,
-            'rename': os.rename,
-            'mkdir': lambda p: os.makedirs(p, exist_ok=True),
-            'listdir': os.listdir,
-            'http_get': self.builtin_http_get,
-            'http_post': self.builtin_http_post,
-            'random': random.random,
-            'randint': random.randint,
-            'sleep': time.sleep,
-            'now': lambda: datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-            'timestamp': time.time,
-            'unique': lambda l: list(dict.fromkeys(l)),
-            'first': lambda l: l[0] if l else None,
-            'last': lambda l: l[-1] if l else None,
-            'empty': lambda x: len(x) == 0 if hasattr(x, '__len__') else x is None,
-            'keys': lambda d: list(d.keys()),
-            'values': lambda d: list(d.values()),
-            'items': lambda d: list(d.items()),
-            'wait': time.sleep,
-            'wait': time.sleep,
-            'push': self._builtin_push,
-            'remove': lambda lst, item: lst.remove(item),
-            'Set': set, 
-            'show': print,
-            'say': print,
-            'today': lambda: datetime.now().strftime("%Y-%m-%d"),
-        }
-        tags = [
-            'div', 'p', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 
-            'span', 'a', 'img', 'button', 'input', 'form', 
-            'ul', 'li', 'ol', 'table', 'tr', 'td', 'th',
-            'html', 'head', 'body', 'title', 'meta', 'link',
-            'script', 'style', 'br', 'hr',
-            'header', 'footer', 'section', 'article', 'nav', 'aside', 'main',
-            'strong', 'em', 'code', 'pre', 'blockquote', 'iframe', 'canvas', 'svg',
-            'css', 'textarea', 'label'
-        ]
-        for t in tags:
-            self.builtins[t] = self._make_tag_fn(t)
-        self.builtins['env'] = lambda name: os.environ.get(str(name), None)
-        self.builtins['int'] = lambda x: int(float(x)) if x else 0
-        self.builtins['str'] = lambda x: str(x)
-        class TimeWrapper:
-            def now(self):
-                return str(int(time.time()))
-        self.builtins['time'] = TimeWrapper()
-        self._init_std_modules()
-        for k, v in self.builtins.items():
-            self.global_env.set(k, v)
-    def _make_tag_fn(self, tag_name):
-        def tag_fn(*args):
-            attrs = {}
-            content = []
-            for arg in args:
-                if isinstance(arg, dict):
-                    attrs.update(arg)
-                elif isinstance(arg, str):
-                    if '=' in arg and not ' ' in arg and arg.split('=')[0].isalnum():
-                        k, v = arg.split('=', 1)
-                        attrs[k] = v
-                    else:
-                        content.append(arg)
-                else:
-                    content.append(str(arg))
-            t = Tag(tag_name, attrs)
-            for c in content:
-                t.add(c)
-            return t
-        return tag_fn
-    def _builtin_map(self, lst, func):
-        if callable(func):
-            return [func(x) for x in lst]
-        raise TypeError("map requires a callable")
-    def _builtin_filter(self, lst, func):
-        if callable(func):
-            return [x for x in lst if func(x)]
-        raise TypeError("filter requires a callable")
-    def _builtin_reduce(self, lst, func, initial=None):
-        if callable(func):
-            if initial is not None:
-                return functools.reduce(func, lst, initial)
-            return functools.reduce(func, lst)
-        raise TypeError("reduce requires a callable")
-    def _builtin_push(self, lst, item):
-        lst.append(item)
-        return None
-    def _init_std_modules(self):
-        self.std_modules = {
-            'math': {
-                'sin': math.sin,
-                'cos': math.cos,
-                'tan': math.tan,
-                'sqrt': math.sqrt,
-                'floor': math.floor,
-                'ceil': math.ceil,
-                'abs': abs,
-                'pow': pow,
-                'log': math.log,
-                'log10': math.log10,
-                'exp': math.exp,
-                'random': random.random,
-                'randint': random.randint,
-                'pi': math.pi,
-                'e': math.e,
-            },
-            'time': {
-                'time': time.time,
-                'sleep': time.sleep,
-                'date': lambda: datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                'year': lambda: datetime.now().year,
-                'month': lambda: datetime.now().month,
-                'day': lambda: datetime.now().day,
-                'hour': lambda: datetime.now().hour,
-                'minute': lambda: datetime.now().minute,
-                'second': lambda: datetime.now().second,
-            },
-            'http': {
-                'get': self._http_get,
-                'post': self._http_post
-            },
-            'env': {
-                'get': lambda k, d=None: os.environ.get(k, d),
-                'set': lambda k, v: os.environ.__setitem__(k, str(v)),
-                'all': lambda: dict(os.environ),
-                'has': lambda k: k in os.environ,
-            },
-            'args': {
-                'get': lambda i: sys.argv[i+1] if i+1 < len(sys.argv) else None,
-                'all': lambda: sys.argv[1:],
-                'count': lambda: len(sys.argv) - 1,
-            },
-            'path': {
-                'join': os.path.join,
-                'basename': os.path.basename,
-                'dirname': os.path.dirname,
-                'exists': os.path.exists,
-                'isfile': os.path.isfile,
-                'isdir': os.path.isdir,
-                'abspath': os.path.abspath,
-                'split': os.path.split,
-                'ext': lambda p: os.path.splitext(p)[1],
-            },
-            'color': {
-                'red': lambda s: f"\033[91m{s}\033[0m",
-                'green': lambda s: f"\033[92m{s}\033[0m",
-                'yellow': lambda s: f"\033[93m{s}\033[0m",
-                'blue': lambda s: f"\033[94m{s}\033[0m",
-                'magenta': lambda s: f"\033[95m{s}\033[0m",
-                'cyan': lambda s: f"\033[96m{s}\033[0m",
-                'bold': lambda s: f"\033[1m{s}\033[0m",
-                'underline': lambda s: f"\033[4m{s}\033[0m",
-                'reset': "\033[0m",
-            },
-            're': {
-                'match': lambda p, s: bool(re.match(p, s)),
-                'search': lambda p, s: re.search(p, s).group() if re.search(p, s) else None,
-                'replace': lambda p, r, s: re.sub(p, r, s),
-                'findall': lambda p, s: re.findall(p, s),
-                'split': lambda p, s: re.split(p, s),
-            },
-        }
-    def _http_get(self, url):
-        with urllib.request.urlopen(url) as response:
-            return response.read().decode('utf-8')
-    def _http_post(self, url, data):
-        if isinstance(data, str):
-            json_data = data.encode('utf-8')
-        else:
-            json_data = json.dumps(data).encode('utf-8')
-        req = urllib.request.Request(url, data=json_data, headers={'Content-Type': 'application/json'})
-        with urllib.request.urlopen(req) as response:
-            return response.read().decode('utf-8')
-    def visit(self, node: Node) -> Any:
-        try:
-            method_name = f'visit_{type(node).__name__}'
-            visitor = getattr(self, method_name, self.generic_visit)
-            return visitor(node)
-        except ReturnException:
-            raise
-        except Exception as e:
-            if not hasattr(e, 'line') and hasattr(node, 'line'):
-                e.line = node.line
-            raise e
-    def generic_visit(self, node: Node):
-        raise Exception(f'No visit_{type(node).__name__} method')
-    def visit_Number(self, node: Number):
-        return node.value
-    def visit_String(self, node: String):
-        return node.value
-    def visit_Boolean(self, node: Boolean):
-        return node.value
-    def visit_ListVal(self, node: ListVal):
-        result = []
-        for e in node.elements:
-            if isinstance(e, Spread):
-                spread_val = self.visit(e.value)
-                if not isinstance(spread_val, list):
-                    raise TypeError(f"Spread operator requires a list, got {type(spread_val).__name__}")
-                result.extend(spread_val)
-            else:
-                result.append(self.visit(e))
-        return result
-    def visit_Dictionary(self, node: Dictionary):
-        return {self.visit(k): self.visit(v) for k, v in node.pairs}
-    def visit_PropertyAssign(self, node: PropertyAssign):
-        instance = self.current_env.get(node.instance_name)
-        val = self.visit(node.value)
-        if isinstance(instance, Instance):
-            instance.data[node.property_name] = val
-            return val
-        elif isinstance(instance, dict):
-            instance[node.property_name] = val
-            return val
-        else:
-             raise TypeError(f"Cannot assign property '{node.property_name}' of non-object '{node.instance_name}'")
-    def visit_VarAccess(self, node: VarAccess):
-        try:
-            return self.current_env.get(node.name)
-        except NameError:
-            if node.name in self.builtins:
-                val = self.builtins[node.name]
-                if node.name in ('random', 'time_now', 'date_str'):
-                    return val()
-                return val
-            if node.name in self.functions:
-                return self.visit_Call(Call(node.name, []))
-            raise
-    def visit_Assign(self, node: Assign):
-        value = self.visit(node.value)
-        self.current_env.set(node.name, value)
-        return value
-    def visit_BinOp(self, node: BinOp):
-        left = self.visit(node.left)
-        right = self.visit(node.right)
-        if node.op == '+':
-            if isinstance(left, str) or isinstance(right, str):
-                return str(left) + str(right)
-            if isinstance(left, list) and isinstance(right, list):
-                return left + right
-            return left + right
-        elif node.op == '-':
-            return left - right
-        elif node.op == '*':
-            return left * right
-        elif node.op == '/':
-            return left / right
-        elif node.op == '%':
-            return left % right
-        elif node.op == '==':
-            return left == right
-        elif node.op == '!=':
-            return left != right
-        elif node.op == '<':
-            return left < right
-        elif node.op == '>':
-            return left > right
-        elif node.op == '<=':
-            return left <= right
-        elif node.op == '>=':
-            return left >= right
-        elif node.op == 'and':
-            return left and right
-        elif node.op == 'or':
-            return left or right
-        elif node.op == 'matches':
-            pattern = right
-            if hasattr(pattern, 'search'):
-                return bool(pattern.search(str(left)))
-            return bool(re.search(str(pattern), str(left)))
-        raise Exception(f"Unknown operator: {node.op}")
-    def visit_Print(self, node: Print):
-        value = self.visit(node.expression)
-        if node.color or node.style:
-            colors = {
-                'red': '91', 'green': '92', 'yellow': '93', 'blue': '94',
-                'magenta': '95', 'cyan': '96'
-            }
-            code_parts = []
-            if node.style == 'bold':
-                code_parts.append('1')
-            if node.color and node.color.lower() in colors:
-                code_parts.append(colors[node.color.lower()])
-            if code_parts:
-                ansi_code = "\033[" + ";".join(code_parts) + "m"
-                print(f"{ansi_code}{value}\033[0m")
-                return value
-        print(value)
-        return value
-    def visit_If(self, node: If):
-        condition = self.visit(node.condition)
-        if condition:
-            for stmt in node.body:
-                self.visit(stmt)
-        elif node.else_body:
-            for stmt in node.else_body:
-                self.visit(stmt)
-    def visit_For(self, node: For):
-        count = self.visit(node.count)
-        if not isinstance(count, int):
-            raise TypeError(f"Loop count must be an integer, got {type(count)}")
-        for _ in range(count):
-            try:
-                for stmt in node.body:
-                    self.visit(stmt)
-            except StopException:
-                break
-            except SkipException:
-                continue
-            except ReturnException:
-                raise
-    def visit_Input(self, node: Input):
-        if node.prompt:
-            return input(node.prompt)
-        return input()
-    def visit_While(self, node: While):
-        while self.visit(node.condition):
-            try:
-                for stmt in node.body:
-                    self.visit(stmt)
-            except StopException:
-                break
-            except SkipException:
-                continue
-            except ReturnException:
-                raise
-    def visit_Try(self, node: Try):
-        try:
-            for stmt in node.try_body:
-                self.visit(stmt)
-        except Exception as e:
-            error_msg = str(e)
-            if hasattr(e, 'message'):
-                error_msg = e.message
-            self.current_env.set(node.catch_var, error_msg)
-            for stmt in node.catch_body:
-                self.visit(stmt)
-    def visit_TryAlways(self, node: TryAlways):
-        try:
-            try:
-                for stmt in node.try_body:
-                    self.visit(stmt)
-            except Exception as e:
-                error_msg = str(e)
-                if hasattr(e, 'message'):
-                    error_msg = e.message
-                self.current_env.set(node.catch_var, error_msg)
-                for stmt in node.catch_body:
-                    self.visit(stmt)
-        finally:
-            for stmt in node.always_body:
-                self.visit(stmt)
-    def visit_UnaryOp(self, node: UnaryOp):
-        val = self.visit(node.right)
-        if node.op == 'not':
-            return not val
-        raise Exception(f"Unknown unary operator: {node.op}")
-    def visit_FunctionDef(self, node: FunctionDef):
-        self.functions[node.name] = node
-    def visit_Return(self, node: Return):
-        value = self.visit(node.value)
-        raise ReturnException(value)
-    def _call_function_def(self, func_def: FunctionDef, args: List[Node]):
-        if len(args) > len(func_def.args):
-             raise TypeError(f"Function '{func_def.name}' expects max {len(func_def.args)} arguments, got {len(args)}")
-        old_env = self.current_env
-        new_env = Environment(parent=self.global_env) 
-        for i, (arg_name, default_node, type_hint) in enumerate(func_def.args):
-            if i < len(args):
-                val = self.visit(args[i])
-            elif default_node is not None:
-                val = self.visit(default_node)
-            else:
-                raise TypeError(f"Missing required argument '{arg_name}' for function '{func_def.name}'")
-            if type_hint:
-                self._check_type(arg_name, val, type_hint)
-            new_env.set(arg_name, val)
-        self.current_env = new_env
-        ret_val = None
-        try:
-            for stmt in func_def.body:
-                val = self.visit(stmt)
-                ret_val = val
-        except ReturnException as e:
-            ret_val = e.value
-        finally:
-            self.current_env = old_env
-        return ret_val
-    def visit_Call(self, node: Call):
-        if node.name in self.builtins:
-             args = [self.visit(a) for a in node.args]
-             result = self.builtins[node.name](*args)
-             if isinstance(result, Tag):
-                 if node.body:
-                     self.web.push(result)
-                     try:
-                         for stmt in node.body:
-                             res = self.visit(stmt)
-                             if res is not None and (isinstance(res, str) or isinstance(res, Tag)):
-                                 self.web.add_text(res)
-                     finally:
-                         self.web.pop()
-                 return result
-             return result
-        try:
-            func = self.current_env.get(node.name)
-            if callable(func):
-                args = [self.visit(a) for a in node.args]
-                return func(*args)
-            curr_obj = func
-            if (isinstance(curr_obj, (list, dict, str)) or isinstance(curr_obj, Instance)):
-                valid_chain = True
-                for arg_node in node.args:
-                    val = self.visit(arg_node)
-                    if isinstance(val, list) and len(val) == 1:
-                        idx = val[0]
-                        try:
-                            curr_obj = curr_obj[idx]
-                        except (IndexError, KeyError) as e:
-                            raise RuntimeError(f"Index/Key error: {e}")
-                        except TypeError:
-                             valid_chain = False; break
-                    else:
-                        valid_chain = False
-                        break
-                if valid_chain:
-                    return curr_obj
-                pass
-        except NameError:
-            pass
-        except NameError:
-            pass
-        if node.name not in self.functions:
-            raise NameError(f"Function '{node.name}' not defined (and not a variable).")
-        func_def = self.functions[node.name]
-        return self._call_function_def(func_def, node.args)
-    def visit_ClassDef(self, node: ClassDef):
-        self.classes[node.name] = node
-    def visit_Instantiation(self, node: Instantiation):
-        if node.class_name not in self.classes:
-            raise NameError(f"Class '{node.class_name}' not defined.")
-        class_def = self.classes[node.class_name]
-        all_properties = self._get_class_properties(class_def)
-        
-        # Check args length
-        # First count how many properties are required (no default)
-        required_count = 0
-        for name, default_val in all_properties:
-            if default_val is None:
-                required_count += 1
-        
-        if len(node.args) < required_count:
-             raise TypeError(f"Structure '{node.class_name}' expects at least {required_count} args, got {len(node.args)}")
-        
-        instance = Instance(class_def)
-        
-        for i, (prop_name, default_val) in enumerate(all_properties):
-            val = None
-            if i < len(node.args):
-                val = self.visit(node.args[i])
-            elif default_val is not None:
-                val = self.visit(default_val)
-            else:
-                # Should be caught by required_count check, but safety fallback
-                raise TypeError(f"Missing argument for property '{prop_name}' in '{node.class_name}'")
-            
-            instance.data[prop_name] = val
-
-        self.current_env.set(node.var_name, instance)
-        return instance
-    def visit_MethodCall(self, node: MethodCall):
-        instance = self.current_env.get(node.instance_name)
-        if isinstance(instance, dict):
-            if node.method_name not in instance:
-                raise AttributeError(f"Module '{node.instance_name}' has no method '{node.method_name}'")
-            method = instance[node.method_name]
-            if isinstance(method, FunctionDef):
-                 return self._call_function_def(method, node.args)
-            elif callable(method):
-                args = [self.visit(a) for a in node.args]
-                try:
-                    return method(*args)
-                except Exception as e:
-                    raise RuntimeError(f"Error calling '{node.instance_name}.{node.method_name}': {e}")
-            elif isinstance(method, (dict, list, str)):
-                 curr_obj = method
-                 valid_chain = True
-                 for arg_node in node.args:
-                    val = self.visit(arg_node)
-                    if isinstance(val, list) and len(val) == 1:
-                        idx = val[0]
-                        try:
-                            curr_obj = curr_obj[idx]
-                        except (IndexError, KeyError) as e:
-                            raise RuntimeError(f"Index/Key error: {e}")
-                        except TypeError:
-                             valid_chain = False; break
-                    else:
-                        valid_chain = False; break
-                 if valid_chain:
-                     return curr_obj
-                 raise TypeError(f"Property '{node.method_name}' is not callable and index access failed.")
-            else:
-                 raise TypeError(f"Property '{node.method_name}' is not callable.")
-        if hasattr(instance, node.method_name) and callable(getattr(instance, node.method_name)):
-             method = getattr(instance, node.method_name)
-             args = [self.visit(a) for a in node.args]
-             return method(*args)
-        if not isinstance(instance, Instance):
-            raise TypeError(f"'{node.instance_name}' is not a structure instance (and has no native method '{node.method_name}').")
-        method_node = self._find_method(instance.class_def, node.method_name)
-        if not method_node:
-            raise AttributeError(f"Structure '{instance.class_def.name}' has no method '{node.method_name}'")
-        old_env = self.current_env
-        new_env = Environment(parent=self.global_env)
-        for k, v in instance.data.items():
-            new_env.set(k, v)
-        if len(node.args) > len(method_node.args):
-             raise TypeError(f"Method '{node.method_name}' expects max {len(method_node.args)} arguments.")
-        for i, (arg_name, default_node, type_hint) in enumerate(method_node.args):
-             if i < len(node.args):
-                 val = self.visit(node.args[i])
-             elif default_node is not None:
-                 val = self.visit(default_node)
-             else:
-                 raise TypeError(f"Missing required argument '{arg_name}' for method '{node.method_name}'")
-             new_env.set(arg_name, val)
-        self.current_env = new_env
-        ret_val = None
-        try:
-            for stmt in method_node.body:
-                self.visit(stmt)
-        except ReturnException as e:
-            ret_val = e.value
-        finally:
-            for k in instance.data.keys():
-                if k in new_env.variables:
-                    instance.data[k] = new_env.variables[k]
-            self.current_env = old_env
-        return ret_val
-    def visit_PropertyAccess(self, node: PropertyAccess):
-        instance = self.current_env.get(node.instance_name)
-        
-        # 1. ShellLite Instance
-        if isinstance(instance, Instance):
-            if node.property_name not in instance.data:
-                 # Check for methods? PropertyAccess usually implies data.
-                 # But in some cases we might want method reference?
-                 raise AttributeError(f"Structure '{instance.class_def.name}' has no property '{node.property_name}'")
-            return instance.data[node.property_name]
-            
-        # 2. Dictionary
-        elif isinstance(instance, dict):
-             if node.property_name in instance:
-                 return instance[node.property_name]
-             raise AttributeError(f"Dictionary has no key '{node.property_name}'")
-
-        # 3. List
-        elif isinstance(instance, list):
-             if node.property_name == 'length':
-                 return len(instance)
-        
-        # 4. String
-        elif isinstance(instance, str):
-             if node.property_name == 'length':
-                 return len(instance)
-
-        # 5. Python Object / Module Interop
-        # If the instance has the attribute natively, return it.
-        # This handles 'math.pi', 'os.name', etc.
-        if hasattr(instance, node.property_name):
-             return getattr(instance, node.property_name)
-             
-        raise TypeError(f"Object '{node.instance_name}' (type {type(instance).__name__}) has no property '{node.property_name}'")
-
-    def visit_Import(self, node: Import):
-        if node.path in self.std_modules:
-            self.current_env.set(node.path, self.std_modules[node.path])
-            return
-        import os 
-        if os.path.exists(node.path):
-             target_path = node.path
-        else:
-             home = os.path.expanduser("~")
-             global_path = os.path.join(home, ".shell_lite", "modules", node.path)
-             if os.path.exists(global_path):
-                 target_path = global_path
-             else:
-                 if not node.path.endswith('.shl'):
-                     global_path_ext = global_path + ".shl"
-                     if os.path.exists(global_path_ext):
-                         target_path = global_path_ext
-                     else:
-                         raise FileNotFoundError(f"Could not find imported file: {node.path} (searched local and global modules)")
-                 else:
-                     raise FileNotFoundError(f"Could not find imported file: {node.path} (searched local and global modules)")
-        if os.path.isdir(target_path):
-             main_shl = os.path.join(target_path, "main.shl")
-             pkg_shl = os.path.join(target_path, f"{os.path.basename(target_path)}.shl")
-             if os.path.exists(main_shl):
-                 target_path = main_shl
-             elif os.path.exists(pkg_shl):
-                 target_path = pkg_shl
-             else:
-                  raise FileNotFoundError(f"Package '{node.path}' is a folder but has no 'main.shl' or '{os.path.basename(target_path)}.shl'.")
-        try:
-            with open(target_path, 'r', encoding='utf-8') as f:
-                code = f.read()
-        except FileNotFoundError:
-            raise FileNotFoundError(f"Could not find imported file: {node.path}")
-        from .lexer import Lexer
-        from .parser import Parser
-        lexer = Lexer(code)
-        tokens = lexer.tokenize()
-        parser = Parser(tokens)
-        statements = parser.parse()
-        for stmt in statements:
-            self.visit(stmt)
-    def _get_class_properties(self, class_def: ClassDef) -> List[tuple[str, Optional[Node]]]:
-        if not hasattr(class_def, 'properties'): return []
-        # Support both old string list and new tuple list for backward compat if needed, though we updated AST
-        props = []
-        for p in class_def.properties:
-            if isinstance(p, tuple):
-                props.append(p)
-            else:
-                props.append((p, None))
-                
-        if class_def.parent:
-            if class_def.parent not in self.classes:
-                raise NameError(f"Parent class '{class_def.parent}' not defined.")
-            parent_def = self.classes[class_def.parent]
-            return self._get_class_properties(parent_def) + props
-        return props
-    def _find_method(self, class_def: ClassDef, method_name: str) -> Optional[FunctionDef]:
-        for m in class_def.methods:
-            if m.name == method_name:
-                return m
-        if class_def.parent:
-             if class_def.parent not in self.classes:
-                raise NameError(f"Parent class '{class_def.parent}' not defined.")
-             parent_def = self.classes[class_def.parent]
-             return self._find_method(parent_def, method_name)
-        return None
-    def builtin_run(self, cmd):
-        try:
-            result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
-            if result.returncode != 0:
-                print(f"Command Error: {result.stderr}")
-            return result.stdout.strip() or result.stderr.strip()
-        except Exception as e:
-            raise RuntimeError(f"Failed to run command: {e}")
-    def builtin_read(self, path):
-        try:
-            with open(path, 'r', encoding='utf-8') as f:
-                return f.read()
-        except Exception as e:
-            raise RuntimeError(f"Failed to read file '{path}': {e}")
-    def builtin_write(self, path, content):
-        try:
-            with open(path, 'w', encoding='utf-8') as f:
-                f.write(str(content))
-            return True
-        except Exception as e:
-            raise RuntimeError(f"Failed to write file '{path}': {e}")
-    def builtin_json_parse(self, json_str):
-        try:
-            return json.loads(json_str)
-        except Exception as e:
-            raise RuntimeError(f"Invalid JSON: {e}")
-    def builtin_json_stringify(self, obj):
-        try:
-            if isinstance(obj, Instance):
-                return json.dumps(obj.data)
-            return json.dumps(obj)
-        except Exception as e:
-            raise RuntimeError(f"JSON stringify failed: {e}")
-    def builtin_http_get(self, url):
-        try:
-            with urllib.request.urlopen(url) as response:
-                return response.read().decode('utf-8')
-        except Exception as e:
-            raise RuntimeError(f"HTTP GET failed for '{url}': {e}")
-    def builtin_http_post(self, url, data_dict):
-        try:
-            if isinstance(data_dict, Instance):
-                data_dict = data_dict.data
-            data = json.dumps(data_dict).encode('utf-8')
-            req = urllib.request.Request(url, data=data, headers={'Content-Type': 'application/json'})
-            with urllib.request.urlopen(req) as response:
-                 return response.read().decode('utf-8')
-        except Exception as e:
-            raise RuntimeError(f"HTTP POST failed for '{url}': {e}")
-    def visit_Lambda(self, node: Lambda):
-        return LambdaFunction(node.params, node.body, self)
-    def visit_Ternary(self, node: Ternary):
-        condition = self.visit(node.condition)
-        if condition:
-            return self.visit(node.true_expr)
-        else:
-            return self.visit(node.false_expr)
-    def visit_ListComprehension(self, node: ListComprehension):
-        iterable = self.visit(node.iterable)
-        if not hasattr(iterable, '__iter__'):
-            raise TypeError(f"Cannot iterate over {type(iterable).__name__}")
-        result = []
-        old_env = self.current_env
-        new_env = Environment(parent=self.current_env)
-        self.current_env = new_env
-        try:
-            for item in iterable:
-                new_env.set(node.var_name, item)
-                if node.condition:
-                    if not self.visit(node.condition):
-                        continue
-                result.append(self.visit(node.expr))
-        finally:
-            self.current_env = old_env
-        return result
-    def visit_Spread(self, node: Spread):
-        return self.visit(node.value)
-    def visit_Alert(self, node: Alert):
-        msg = self.visit(node.message)
-        root = tk.Tk()
-        root.withdraw()
-        root.attributes('-topmost', True)
-        messagebox.showinfo("Alert", str(msg))
-        root.destroy()
-    def visit_Prompt(self, node: Prompt):
-        prompt = self.visit(node.prompt)
-        root = tk.Tk()
-        root.withdraw()
-        root.attributes('-topmost', True)
-        val = simpledialog.askstring("Input", str(prompt))
-        root.destroy()
-        return val if val is not None else ""
-    def visit_Confirm(self, node: Confirm):
-        prompt = self.visit(node.prompt)
-        root = tk.Tk()
-        root.withdraw()
-        root.attributes('-topmost', True)
-        val = messagebox.askyesno("Confirm", str(prompt))
-        root.destroy()
-        return val
-    def visit_Spawn(self, node: Spawn):
-        executor = concurrent.futures.ThreadPoolExecutor(max_workers=1)
-        future = executor.submit(self.visit, node.call)
-        return future
-    def visit_Await(self, node: Await):
-        task = self.visit(node.task)
-        if isinstance(task, concurrent.futures.Future):
-            return task.result()
-        raise TypeError(f"Cannot await non-task object: {type(task)}")
-    def visit_Regex(self, node: Regex):
-        return re.compile(node.pattern)
-    def visit_FileWatcher(self, node: FileWatcher):
-        path = self.visit(node.path)
-        if not os.path.exists(path):
-            print(f"Warning: Watching non-existent file {path}")
-            last_mtime = 0
-        else:
-            last_mtime = os.path.getmtime(path)
-        try:
-            while True:
-                current_exists = os.path.exists(path)
-                if current_exists:
-                    current_mtime = os.path.getmtime(path)
-                    if current_mtime != last_mtime:
-                        last_mtime = current_mtime
-                        for stmt in node.body:
-                            self.visit(stmt)
-                time.sleep(1) 
-        except StopException:
-            pass 
-        except ReturnException:
-            raise
-    def _check_type(self, arg_name, val, type_hint):
-        if type_hint == 'int' and not isinstance(val, int):
-            raise TypeError(f"Argument '{arg_name}' expects int, got {type(val).__name__}")
-        elif type_hint == 'str' and not isinstance(val, str):
-            raise TypeError(f"Argument '{arg_name}' expects str, got {type(val).__name__}")
-        elif type_hint == 'bool' and not isinstance(val, bool):
-             raise TypeError(f"Argument '{arg_name}' expects bool, got {type(val).__name__}")
-        elif type_hint == 'float' and not isinstance(val, (float, int)):
-             raise TypeError(f"Argument '{arg_name}' expects float, got {type(val).__name__}")
-        elif type_hint == 'list' and not isinstance(val, list):
-             raise TypeError(f"Argument '{arg_name}' expects list, got {type(val).__name__}")
-    def visit_ConstAssign(self, node: ConstAssign):
-        value = self.visit(node.value)
-        self.current_env.set_const(node.name, value)
-        return value
-    def visit_ForIn(self, node: ForIn):
-        iterable = self.visit(node.iterable)
-        if not hasattr(iterable, '__iter__'):
-            raise TypeError(f"Cannot iterate over {type(iterable).__name__}")
-        old_env = self.current_env
-        new_env = Environment(parent=self.current_env)
-        self.current_env = new_env
-        try:
-            for item in iterable:
-                new_env.set(node.var_name, item)
-                for stmt in node.body:
-                    self.visit(stmt)
-        except ReturnException:
-            raise
-        finally:
-            self.current_env = old_env
-    def visit_IndexAccess(self, node: IndexAccess):
-        obj = self.visit(node.obj)
-        index = self.visit(node.index)
-        if isinstance(obj, list):
-            if not isinstance(index, int):
-                raise TypeError(f"List indices must be integers, got {type(index).__name__}")
-            return obj[index]
-        elif isinstance(obj, dict):
-            return obj[index]
-        elif isinstance(obj, str):
-            if not isinstance(index, int):
-                raise TypeError(f"String indices must be integers, got {type(index).__name__}")
-            return obj[index]
-        else:
-            raise TypeError(f"'{type(obj).__name__}' object is not subscriptable")
-    def visit_Stop(self, node: Stop):
-        raise StopException()
-    def visit_Skip(self, node: Skip):
-        raise SkipException()
-    def visit_PythonImport(self, node: PythonImport):
-        try:
-            mod = importlib.import_module(node.module_name)
-            name = node.alias if node.alias else node.module_name.split('.')[0]
-            self.global_env.set(name, mod)
-        except ImportError as e:
-            raise RuntimeError(f"Could not import python module '{node.module_name}': {e}")
-            
-    def visit_Throw(self, node: Throw):
-        message = self.visit(node.message)
-        raise ShellLiteError(str(message))
-    def visit_Unless(self, node: Unless):
-        condition = self.visit(node.condition)
-        if not condition:
-            for stmt in node.body:
-                self.visit(stmt)
-        elif node.else_body:
-            for stmt in node.else_body:
-                self.visit(stmt)
-    def visit_Until(self, node: Until):
-        while not self.visit(node.condition):
-            try:
-                for stmt in node.body:
-                    self.visit(stmt)
-            except StopException:
-                break
-            except SkipException:
-                continue
-            except ReturnException:
-                raise
-    def visit_Repeat(self, node: Repeat):
-        count = self.visit(node.count)
-        if not isinstance(count, int):
-            raise TypeError(f"repeat count must be an integer, got {type(count).__name__}")
-        for _ in range(count):
-            try:
-                for stmt in node.body:
-                    self.visit(stmt)
-            except StopException:
-                break
-            except SkipException:
-                continue
-            except ReturnException:
-                raise
-    def visit_When(self, node: When):
-        value = self.visit(node.value)
-        for match_val, body in node.cases:
-            if self.visit(match_val) == value:
-                for stmt in body:
-                    self.visit(stmt)
-                return
-        if node.otherwise:
-            for stmt in node.otherwise:
-                self.visit(stmt)
-    def visit_Execute(self, node: Execute):
-        code = self.visit(node.code)
-        if not isinstance(code, str):
-            raise TypeError(f"execute requires a string, got {type(code).__name__}")
-        from .lexer import Lexer
-        from .parser import Parser
-        lexer = Lexer(code)
-        tokens = lexer.tokenize()
-        parser = Parser(tokens)
-        statements = parser.parse()
-        result = None
-        for stmt in statements:
-            result = self.visit(stmt)
-        self.current_env.set('__exec_result__', result)
-        return result
-    def visit_ImportAs(self, node: ImportAs):
-        if node.path in self.std_modules:
-            self.current_env.set(node.alias, self.std_modules[node.path])
-            return
-        old_funcs_keys = set(self.functions.keys())
-        module_env = Environment(parent=self.global_env)
-        old_env = self.current_env
-        self.current_env = module_env
-        module_env = Environment(parent=self.global_env)
-        old_env = self.current_env
-        self.current_env = module_env
-        if os.path.exists(node.path):
-             target_path = node.path
-        else:
-             home = os.path.expanduser("~")
-             global_path = os.path.join(home, ".shell_lite", "modules", node.path)
-             if os.path.exists(global_path):
-                 target_path = global_path
-             else:
-                  if not node.path.endswith('.shl'):
-                       global_path_ext = global_path + ".shl"
-                       if os.path.exists(global_path_ext):
-                            target_path = global_path_ext
-                       else:
-                            self.current_env = old_env
-                            raise FileNotFoundError(f"Could not find imported file: {node.path} (searched local and global modules)")
-                  else:
-                       self.current_env = old_env
-                       raise FileNotFoundError(f"Could not find imported file: {node.path} (searched local and global modules)")
-        if os.path.isdir(target_path):
-             main_shl = os.path.join(target_path, "main.shl")
-             pkg_shl = os.path.join(target_path, f"{os.path.basename(target_path)}.shl")
-             if os.path.exists(main_shl):
-                 target_path = main_shl
-             elif os.path.exists(pkg_shl):
-                 target_path = pkg_shl
-             else:
-                  self.current_env = old_env
-                  raise FileNotFoundError(f"Package '{node.path}' is a folder but has no 'main.shl' or '{os.path.basename(target_path)}.shl'.")
-        try:
-            with open(target_path, 'r', encoding='utf-8') as f:
-                code = f.read()
-            from .lexer import Lexer
-            from .parser import Parser
-            lexer = Lexer(code)
-            tokens = lexer.tokenize()
-            parser = Parser(tokens)
-            statements = parser.parse()
-            for stmt in statements:
-                self.visit(stmt)
-            module_exports = {}
-            module_exports.update(module_env.variables)
-            current_funcs_keys = set(self.functions.keys())
-            new_funcs = current_funcs_keys - old_funcs_keys
-            for fname in new_funcs:
-                func_node = self.functions[fname]
-                module_exports[fname] = func_node
-                del self.functions[fname]
-            self.current_env = old_env
-            self.current_env.set(node.alias, module_exports)
-        except Exception as e:
-            self.current_env = old_env
-            raise RuntimeError(f"Failed to import '{node.path}': {e}")
-    def visit_Forever(self, node: Forever):
-        while True:
-            try:
-                for stmt in node.body:
-                    self.visit(stmt)
-            except StopException:
-                break
-            except SkipException:
-                continue
-            except ReturnException:
-                raise
-    def visit_Exit(self, node: Exit):
-        code = 0
-        if node.code:
-            code = self.visit(node.code)
-            sys.exit(int(code))
-        sys.exit(0)
-
-    # -------------------------------------------------------------------------
-    # Project Polaris: Phase 2 (The Canvas - Native UI)
-    # -------------------------------------------------------------------------
-    def visit_App(self, node: App):
-        # We need a root for the app
-        import tkinter as tk
-        from tkinter import messagebox
-        root = tk.Tk()
-        root.title(node.title)
-        root.geometry(f"{node.width}x{node.height}")
-        
-        # Store root for potential access, though mostly we use 'master' passed down
-        # Ideally we pass 'parent' to visits, but we don't have that signature.
-        # So we'll use a stack or a temporary context.
-        self.ui_parent_stack = [root]
-        
-        # Define a helpful alert function available in UI context
-        def ui_alert(msg):
-            messagebox.showinfo("Message", str(msg))
-        self.current_env.set("alert", ui_alert)
-
-        try:
-            for child in node.body:
-                self.visit(child)
-        finally:
-            self.ui_parent_stack.pop()
-            
-        root.mainloop()
-
-    def visit_Layout(self, node: Layout):
-        parent = self.ui_parent_stack[-1]
-        
-        # Create a frame for the layout
-        frame = tk.Frame(parent)
-        
-        # Pack options based on layout type of THIS container relative to parent??
-        # Usually Layout implies how CHILDREN are arranged.
-        # But here 'column' means "I am a column" -> children stacked vertically.
-        # 'row' means "I am a row" -> children stacked horizontally.
-        
-        # In Tkinter, pack() defaults to vertical (column).
-        # side=LEFT makes it horizontal (row).
-        
-        # We start by adding the frame to the parent.
-        # If parent is a Column, we pack(side=TOP). If Row, pack(side=LEFT).
-        # But simplified: Just use pack(fill=X) or something.
-        frame.pack(side=tk.TOP, fill=tk.BOTH, expand=True, padx=5, pady=5)
-        
-        self.ui_parent_stack.append((frame, node.layout_type))
-        try:
-            for child in node.body:
-                self.visit(child)
-        finally:
-            self.ui_parent_stack.pop()
-
-    def visit_Widget(self, node: Widget):
-        from tkinter import messagebox
-        parent_ctx = self.ui_parent_stack[-1]
-        if isinstance(parent_ctx, tuple):
-            parent, layout_mode = parent_ctx
-        else:
-            parent = parent_ctx
-            layout_mode = 'column' # Default to column
-            
-        widget = None
-        if node.widget_type == 'button':
-            # Handle event
-            def on_click():
-                if node.event_handler:
-                    try:
-                        for stmt in node.event_handler:
-                            self.visit(stmt)
-                    except Exception as e:
-                        messagebox.showerror("Error", str(e))
-                        
-            widget = tk.Button(parent, text=node.label, command=on_click)
-            
-        elif node.widget_type == 'input':
-            lbl = tk.Label(parent, text=node.label)
-            pack_opts = {'side': tk.TOP, 'anchor': 'w'} if layout_mode == 'column' else {'side': tk.LEFT}
-            lbl.pack(**pack_opts)
-            
-            widget = tk.Entry(parent)
-            
-            # Store accessor in Env so we can read .value
-            if node.var_name:
-                # We can't store the widget directly because .value access visits PropertyAccess
-                # which expects dict, list, or python object.
-                # Tkinter Entry has get().
-                # We wrap it or just rely on 'visit_PropertyAccess' (Phase 1)
-                # By default Tkinter widgets store config. 
-                # Let's verify if widget.value works natively? No.
-                # So we wrap it.
-                class InputWrapper:
-                    def __init__(self, w): self.w = w
-                    @property
-                    def value(self): return self.w.get()
-                    @property
-                    def text(self): return self.w.get()
-                
-                self.current_env.set(node.var_name, InputWrapper(widget))
-
-        elif node.widget_type == 'heading':
-            widget = tk.Label(parent, text=node.label, font=("Helvetica", 16, "bold"))
-            
-        elif node.widget_type == 'text':
-            widget = tk.Label(parent, text=node.label)
-            
-        if widget:
-            # Layout the widget
-            if layout_mode == 'column':
-                widget.pack(side=tk.TOP, pady=5, fill=tk.X)
-            else:
-                widget.pack(side=tk.LEFT, padx=5)
-
-    def visit_Make(self, node: Make):
-        if node.class_name not in self.classes:
-            raise NameError(f"Thing '{node.class_name}' not defined.")
-        class_def = self.classes[node.class_name]
-        props = self._get_class_properties(class_def)
-
-        # Check args length
-        required_count = 0
-        for name, default_val in props:
-            if default_val is None:
-                required_count += 1
-
-        if len(node.args) < required_count:
-             raise TypeError(f"Thing '{node.class_name}' expects at least {required_count} values, got {len(node.args)}")
-        
-        instance = Instance(class_def)
-        
-        for i, (prop_name, default_val) in enumerate(props):
-            val = None
-            if i < len(node.args):
-                val = self.visit(node.args[i])
-            elif default_val is not None:
-                val = self.visit(default_val)
-            else:
-                raise TypeError(f"Missing argument for property '{prop_name}' in '{node.class_name}'")
-            
-            instance.data[prop_name] = val
-            
-        return instance
-    def visit_Convert(self, node: Convert):
-        val = self.visit(node.expression)
-        if node.target_format.lower() == 'json':
-             if isinstance(val, str):
-                 try:
-                     return json.loads(val)
-                 except: 
-                     return json.dumps(val) 
-             else:
-                 if isinstance(val, Instance):
-                     return json.dumps(val.data)
-                 return json.dumps(val) 
-        raise ValueError(f"Unknown conversion format: {node.target_format}")
-    def visit_ProgressLoop(self, node: ProgressLoop):
-        loop = node.loop_node
-        if isinstance(loop, Repeat):
-             count = self.visit(loop.count)
-             if not isinstance(count, int): count = 0
-             print(f"Progress: [                    ] 0%", end='\r')
-             for i in range(count):
-                 percent = int((i / count) * 100)
-                 bar = '=' * int(percent / 5)
-                 print(f"Progress: [{bar:<20}] {percent}%", end='\r')
-                 try:
-                     for stmt in loop.body:
-                         self.visit(stmt)
-                 except: pass 
-             print(f"Progress: [{'='*20}] 100%           ")
-        elif isinstance(loop, For):
-             count = self.visit(loop.count)
-             for i in range(count):
-                 percent = int((i / count) * 100)
-                 bar = '=' * int(percent / 5)
-                 print(f"Progress: [{bar:<20}] {percent}%", end='\r')
-                 try:
-                    for stmt in loop.body:
-                        self.visit(stmt)
-                 except: pass
-             print(f"Progress: [{'='*20}] 100%           ")
-        elif isinstance(loop, ForIn):
-            iterable = self.visit(loop.iterable)
-            total = len(iterable) if hasattr(iterable, '__len__') else 0
-            i = 0
-            for item in iterable:
-                if total > 0:
-                    percent = int((i / total) * 100)
-                    bar = '=' * int(percent / 5)
-                    print(f"Progress: [{bar:<20}] {percent}%", end='\r')
-                self.current_env.set(loop.var_name, item)
-                try:
-                    for stmt in loop.body:
-                        self.visit(stmt)
-                except: pass
-                i += 1
-            if total > 0:
-                print(f"Progress: [{'='*20}] 100%           ")
-    def visit_DatabaseOp(self, node: DatabaseOp):
-        if node.op == 'open':
-            path = self.visit(node.args[0])
-            self.db_conn = sqlite3.connect(path, check_same_thread=False)
-            return self.db_conn
-        elif node.op == 'close':
-            if self.db_conn:
-                self.db_conn.close()
-                self.db_conn = None
-        elif node.op == 'exec':
-            if not self.db_conn:
-                raise RuntimeError("Database not open. Use 'db open \"path\"' first.")
-            sql = self.visit(node.args[0])
-            params = [self.visit(arg) for arg in node.args[1:]]
-            cursor = self.db_conn.cursor()
-            cursor.execute(sql, params)
-            self.db_conn.commit()
-            return cursor.lastrowid
-        elif node.op == 'query':
-            if not self.db_conn:
-                raise RuntimeError("Database not open. Use 'db open \"path\"' first.")
-            sql = self.visit(node.args[0])
-            params = [self.visit(arg) for arg in node.args[1:]]
-            cursor = self.db_conn.cursor()
-            cursor.execute(sql, params)
-            columns = [description[0] for description in cursor.description] if cursor.description else []
-            rows = cursor.fetchall()
-            result = []
-            for row in rows:
-                result.append(dict(zip(columns, row)))
-            return result
-    def visit_ServeStatic(self, node: ServeStatic):
-        folder = str(self.visit(node.folder))
-        url_prefix = str(self.visit(node.url))
-        if not url_prefix.startswith('/'): url_prefix = '/' + url_prefix
-        if not os.path.isdir(folder):
-            print(f"Warning: Static folder '{folder}' does not exist.")
-        self.static_routes[url_prefix] = folder
-        print(f"Serving static files from '{folder}' at '{url_prefix}'")
-    def visit_Every(self, node: Every):
-        interval = self.visit(node.interval)
-        if node.unit == 'minutes': interval *= 60
-        try:
-            while True:
-                for stmt in node.body: self.visit(stmt)
-                time.sleep(interval)
-        except KeyboardInterrupt: pass
-    def visit_After(self, node: After):
-        delay = self.visit(node.delay)
-        if node.unit == 'minutes': delay *= 60
-        time.sleep(delay)
-        for stmt in node.body: self.visit(stmt)
-    def visit_OnRequest(self, node: OnRequest):
-        path_str = self.visit(node.path)
-        if path_str == '__middleware__':
-            self.middleware_routes.append(node.body)
-            return
-        regex_pattern = "^" + path_str + "$"
-        if ':' in path_str:
-            regex_pattern = "^" + re.sub(r':(\w+)', r'(?P<\1>[^/]+)', path_str) + "$"
-        compiled = re.compile(regex_pattern)
-        self.http_routes.append((path_str, compiled, node.body))
-    def visit_Listen(self, node: Listen):
-        port_val = self.visit(node.port)
-        interpreter_ref = self
-        class ShellLiteHandler(BaseHTTPRequestHandler):
-            def log_message(self, format, *args): pass 
-            def do_GET(self): 
-                self.handle_req()
-            def do_POST(self):
-                content_length = int(self.headers.get('Content-Length', 0))
-                content_type = self.headers.get('Content-Type', '')
-                post_data = self.rfile.read(content_length).decode('utf-8')
-                params = {}
-                json_data = None
-                if 'application/json' in content_type:
-                    try:
-                        json_data = json.loads(post_data)
-                    except:
-                        pass
-                else:
-                    if post_data:
-                        parsed = urllib.parse.parse_qs(post_data)
-                        params = {k: v[0] for k, v in parsed.items()}
-                self.handle_req(params, json_data)
-            def do_HEAD(self):
-                self.handle_req()
-            def handle_req(self, post_params=None, json_data=None):
-                try:
-                    if post_params is None: post_params = {}
-                    path = self.path
-                    if '?' in path: path = path.split('?')[0]
-                    req_obj = {
-                        "method": self.command, 
-                        "path": path,
-                        "params": post_params,
-                        "form": post_params, 
-                        "json": json_data
-                    }
-                    interpreter_ref.global_env.set("request", req_obj)
-                    interpreter_ref.global_env.set("REQUEST_METHOD", self.command) 
-                    for prefix, folder in interpreter_ref.static_routes.items():
-                        if path.startswith(prefix):
-                            clean_path = path[len(prefix):]
-                            if clean_path.startswith('/'): clean_path = clean_path[1:]
-                            if clean_path == '': clean_path = 'index.html'
-                            file_path = os.path.join(folder, clean_path)
-                            if os.path.exists(file_path) and os.path.isfile(file_path):
-                                 self.send_response(200)
-                                 ct = 'application/octet-stream'
-                                 if file_path.endswith('.css'): ct = 'text/css'
-                                 elif file_path.endswith('.html'): ct = 'text/html'
-                                 elif file_path.endswith('.js'): ct = 'application/javascript'
-                                 self.send_header('Content-Type', ct)
-                                 self.end_headers()
-                                 if self.command != 'HEAD':
-                                     with open(file_path, 'rb') as f: self.wfile.write(f.read())
-                                 return
-                    matched_body = None
-                    path_params = {}
-                    for pattern, regex, body in interpreter_ref.http_routes:
-                        match = regex.match(path)
-                        if match:
-                            matched_body = body
-                            path_params = match.groupdict()
-                            break
-                    if matched_body:
-                        for mw in interpreter_ref.middleware_routes:
-                             for stmt in mw: interpreter_ref.visit(stmt)
-                        for k, v in path_params.items():
-                            interpreter_ref.global_env.set(k, v)
-                        for k, v in post_params.items():
-                            interpreter_ref.global_env.set(k, v)
-                        interpreter_ref.web.stack = []
-                        response_body = ""
-                        result = None
-                        try:
-                            for stmt in matched_body:
-                                result = interpreter_ref.visit(stmt)
-                        except ReturnException as re:
-                            result = re.value
-                        if interpreter_ref.web.stack:
-                             pass
-                        if isinstance(result, Tag): response_body = str(result)
-                        elif result is not None: response_body = str(result)
-                        else: response_body = "OK"
-                        self.send_response(200)
-                        self.send_header('Content-Type', 'text/html')
-                        self.end_headers()
-                        if self.command != 'HEAD':
-                            self.wfile.write(response_body.encode())
-                    else:
-                        self.send_response(404)
-                        self.end_headers()
-                        if self.command != 'HEAD':
-                            self.wfile.write(b'Not Found')
-                except Exception as e:
-                    print(f"DEBUG: Server Exception: {e}")
-                    import traceback
-                    traceback.print_exc()
-                    try:
-                        self.send_response(500)
-                        self.end_headers()
-                        if self.command != 'HEAD':
-                            self.wfile.write(str(e).encode())
-                    except: pass
-        server = HTTPServer(('0.0.0.0', port_val), ShellLiteHandler)
-        print(f"\n  ShellLite Server v0.04.3 is running!")
-        print(f"  \u001b[1;36m➜\u001b[0m  Local:   \u001b[1;4;36mhttp://localhost:{port_val}/\u001b[0m\n")
-        try: server.serve_forever()
-        except KeyboardInterrupt: 
-            print("\n  Server stopped.")
-            pass
-    def visit_DatabaseOp(self, node: DatabaseOp):
-        if node.op == 'open':
-            path = self.visit(node.args[0])
-            self.db_conn = sqlite3.connect(path)
-            self.db_conn.row_factory = lambda c, r: {col[0]: r[idx] for idx, col in enumerate(c.description)}
-            return True
-        elif node.op == 'close':
-            if self.db_conn: self.db_conn.close(); self.db_conn = None
-            return True
-        elif node.op == 'exec':
-            if not self.db_conn: raise RuntimeError("Database not open")
-            sql = self.visit(node.args[0])
-            params = []
-            if len(node.args) > 1:
-                val = self.visit(node.args[1])
-                params = val if isinstance(val, list) else [val]
-            c = self.db_conn.cursor(); c.execute(sql, params); self.db_conn.commit()
-            return c.lastrowid
-        elif node.op == 'query':
-            if not self.db_conn: raise RuntimeError("Database not open")
-            sql = self.visit(node.args[0])
-            params = []
-            if len(node.args) > 1:
-                val = self.visit(node.args[1])
-                params = val if isinstance(val, list) else [val]
-            c = self.db_conn.cursor(); c.execute(sql, params)
-            return c.fetchall()
-    def visit_Download(self, node: Download):
-        url = self.visit(node.url)
-        filename = url.split('/')[-1] or "downloaded_file"
-        print(f"Downloading {filename}...")
-        try:
-             with urllib.request.urlopen(url) as response:
-                 with open(filename, 'wb') as f:
-                     shutil.copyfileobj(response, f)
-             print(f"Download complete: {filename}")
-        except urllib.error.URLError as e:
-             print(f"Error: Could not connect to {url}. Reason: {e}")
-        except PermissionError:
-             print(f"Error: Permission denied writing to {filename}.")
-        except Exception as e:
-             print(f"Error: Download failed: {e}")
-    def visit_ArchiveOp(self, node: ArchiveOp):
-        source = str(self.visit(node.source))
-        target = str(self.visit(node.target))
-        try:
-            if node.op == 'compress':
-                 print(f"Compressing '{source}' to '{target}'...")
-                 if os.path.isfile(source):
-                     with zipfile.ZipFile(target, 'w') as zipf:
-                         zipf.write(source, arcname=os.path.basename(source))
-                 elif os.path.isdir(source):
-                     shutil.make_archive(target.replace('.zip',''), 'zip', source)
-                 else:
-                     print(f"Error: Source '{source}' does not exist.")
-                     return
-                 print("Compression complete.")
-            else: 
-                 print(f"Extracting '{source}' to '{target}'...")
-                 if not os.path.exists(source):
-                      print(f"Error: Archive '{source}' does not exist.")
-                      return
-                 with zipfile.ZipFile(source, 'r') as zipf:
-                     zipf.extractall(target)
-                 print("Extraction complete.")
-        except zipfile.BadZipFile:
-             print(f"Error: '{source}' is not a valid zip file.")
-        except Exception as e:
-             print(f"Error: Archive operation failed: {e}")
-    def visit_CsvOp(self, node: CsvOp):
-        path = self.visit(node.path)
-        if node.op == 'load':
-            with open(path, 'r', newline='') as f:
-                reader = csv.DictReader(f)
-                return [row for row in reader]
-        else: 
-            data = self.visit(node.data)
-            if not isinstance(data, list):
-                 data = [data] 
-            if not data: return 
-            rows = []
-            for item in data:
-                 if isinstance(item, Instance):
-                     rows.append(item.data)
-                 elif isinstance(item, dict):
-                     rows.append(item)
-                 elif isinstance(item, dict):
-                     rows.append(item)
-                 else:
-                     print("Error: Only lists of objects/dictionaries can be saved to CSV.")
-                     return
-            if rows:
-                try:
-                    keys = rows[0].keys()
-                    with open(path, 'w', newline='') as f:
-                        writer = csv.DictWriter(f, fieldnames=keys)
-                        writer.writeheader()
-                        writer.writerows(rows)
-                    print(f"Saved {len(rows)} rows to '{path}'.")
-                except Exception as e:
-                    print(f"Error saving CSV: {e}")
-    def visit_ClipboardOp(self, node: ClipboardOp):
-        if 'pyperclip' not in sys.modules:
-             raise RuntimeError("Install 'pyperclip' for clipboard support.")
-        if node.op == 'copy':
-             content = str(self.visit(node.content))
-             pyperclip.copy(content)
-        else:
-             return pyperclip.paste()
-    def visit_AutomationOp(self, node: AutomationOp):
-        args = [self.visit(a) for a in node.args]
-        if node.action == 'press':
-             if 'keyboard' not in sys.modules: raise RuntimeError("Install 'keyboard'")
-             keyboard.press_and_release(args[0])
-        elif node.action == 'type':
-             if 'keyboard' not in sys.modules: raise RuntimeError("Install 'keyboard'")
-             keyboard.write(str(args[0]))
-        elif node.action == 'click':
-             if 'mouse' not in sys.modules: raise RuntimeError("Install 'mouse'")
-             mouse.move(args[0], args[1], absolute=True, duration=0.2)
-             mouse.click('left')
-        elif node.action == 'notify':
-             if 'plyer' not in sys.modules: raise RuntimeError("Install 'plyer'")
-             notification.notify(title=str(args[0]), message=str(args[1]))
-    def visit_DateOp(self, node: DateOp):
-        if node.expr == 'today':
-            return datetime.now().strftime("%Y-%m-%d")
-        today = datetime.now()
-        s = node.expr.lower().strip()
-        if s == 'tomorrow':
-            d = today + timedelta(days=1)
-            return d.strftime("%Y-%m-%d")
-        elif s == 'yesterday':
-            d = today - timedelta(days=1)
-            return d.strftime("%Y-%m-%d")
-        days = ['monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday', 'sunday']
-        if s.startswith('next '):
-            day_str = s.replace('next ', '').strip()
-            if day_str in days:
-                 target_idx = days.index(day_str)
-                 current_idx = today.weekday()
-                 days_ahead = target_idx - current_idx
-                 if days_ahead <= 0: days_ahead += 7
-                 d = today + timedelta(days=days_ahead)
-                 return d.strftime("%Y-%m-%d")
-        return s 
-    def visit_FileWrite(self, node: FileWrite):
-        path = str(self.visit(node.path))
-        content = str(self.visit(node.content))
-        try:
-            with open(path, node.mode, encoding='utf-8') as f:
-                f.write(content)
-            print(f"{'Appended to' if node.mode == 'a' else 'Written to'} file '{path}'")
-        except Exception as e:
-            raise RuntimeError(f"File operation failed: {e}")
-    def visit_FileRead(self, node: FileRead):
-        path = str(self.visit(node.path))
-        try:
-            with open(path, 'r', encoding='utf-8') as f:
-                return f.read()
-        except FileNotFoundError:
-             raise FileNotFoundError(f"File '{path}' not found.")
-             raise RuntimeError(f"Read failed: {e}")
-    def _builtin_upper(self, s, only_letters=False):
-        if not only_letters:
-            return s.upper()
-        # "UPPER words ONLY LETTERS" -> Uppercase normal letters, leave others?
-        # Or maybe it means "Only extract uppercase letters"?
-        # User output shows: "HELLO WORLD 123" -> "HELLO WORLD 123" (normal)
-        # Wait, user screenshot says: 
-        # text = "hello world 123"
-        # words = split text
-        # say upper words only letters
-        # Error: Variable 'only' is not defined.
-        # So maybe they want to UPPERCASE ONLY LETTERS? digits remain same? .upper() does that.
-        # But maybe they mean "remove non-letters"?
-        # "upper words only letters" -> "HELLO WORLD". 
-        # If "only letters" means filter?
-        # Let's assume it means "uppercase only the letters" which is standard behavior?
-        # Or maybe "uppercase, and keep only letters".
-        # Let's look at user intent. "upper words only letters".
-        # Likely: Uppercase and remove numbers/symbols?
-        # If input is "hello world 123", output might be "HELLO WORLD".
-        if only_letters:
-             import re
-             return re.sub(r'[^a-zA-Z\s]', '', s).upper()
-        return s.upper()
-
-    def _builtin_sum_range(self, start, end, condition=None):
-        # condition is a string, e.g. "even", "odd", "prime", "digits"
-        total = 0
-        s = int(start)
-        e = int(end)
-        for i in range(s, e + 1):
-             include = True
-             if condition == 'even' and i % 2 != 0: include = False
-             elif condition == 'odd' and i % 2 == 0: include = False
-             elif condition == 'prime':
-                 if i < 2: include = False
-                 else:
-                     for k in range(2, int(i ** 0.5) + 1):
-                         if i % k == 0:
-                             include = False; break
-             elif condition == 'digits':
-                  # sum of digits? Or sum of numbers that are single digits?
-                  # "sum of numbers from 1 to 10 when digits" -> unclear.
-                  # Assuming "digits" meant specific property.
-                  pass
-             
-             if include:
-                 total += i
-        return total
-
-    def _builtin_range_list(self, start, end, condition=None):
-        res = []
-        s = int(start)
-        e = int(end)
-        for i in range(s, e + 1):
-             include = True
-             if condition == 'even' and i % 2 != 0: include = False
-             elif condition == 'odd' and i % 2 == 0: include = False
-             elif condition == 'prime':
-                 if i < 2: include = False
-                 else:
-                     for k in range(2, int(i ** 0.5) + 1):
-                         if i % k == 0:
-                             include = False; break
-             
-             if include:
-                 res.append(i)
-        return res