shell-lite 0.3.5__py3-none-any.whl → 0.4.1__py3-none-any.whl

shell_lite/ast_nodes.py

@@ -83,7 +83,7 @@ class Return(Node):
 @dataclass
 class ClassDef(Node):
     name: str
-    properties: List[str]
+    properties: List[tuple[str, Optional[Node]]]
     methods: List[FunctionDef]
     parent: Optional[str] = None
 @dataclass
@@ -272,3 +272,26 @@ class FileRead(Node):
 class DatabaseOp(Node):
     op: str
     args: List[Node]
+@dataclass
+class PythonImport(Node):
+    module_name: str
+    alias: Optional[str]
+
+@dataclass
+class App(Node):
+    title: str
+    width: int
+    height: int
+    body: List[Node]
+
+@dataclass
+class Widget(Node):
+    widget_type: str  # 'button', 'input', 'heading', 'text'
+    label: str
+    var_name: Optional[str] = None
+    event_handler: Optional[List[Node]] = None # For buttons with 'do:'
+
+@dataclass
+class Layout(Node):
+    layout_type: str # 'column', 'row'
+    body: List[Node]

shell_lite/compiler.py

@@ -360,8 +360,20 @@ class Compiler:
         parent = node.parent if node.parent else "Instance"
         code = f"class {node.name}({parent}):\n"
         self.indentation += 1
-        args = ["self"] + node.properties
-        assigns = [f"self.{p} = {p}" for p in node.properties]
+        args = ["self"]
+        assigns = []
+        for prop in node.properties:
+            if isinstance(prop, tuple):
+                name, default = prop
+                if default:
+                    args.append(f"{name}={self.visit(default)}")
+                else:
+                    args.append(name)
+                assigns.append(f"self.{name} = {name}")
+            else:
+                args.append(prop)
+                assigns.append(f"self.{prop} = {prop}")
+
         if not assigns:
             assigns = ["pass"]
         code += f"{self.indent()}def __init__({', '.join(args)}):\n"

shell_lite/interpreter.py

@@ -2,6 +2,7 @@ from typing import Any, Dict, List, Callable
 from .ast_nodes import *
 from .lexer import Token, Lexer
 from .parser import Parser
+import importlib
 import operator
 import re
 import os
@@ -618,12 +619,31 @@ class Interpreter:
             raise NameError(f"Class '{node.class_name}' not defined.")
         class_def = self.classes[node.class_name]
         all_properties = self._get_class_properties(class_def)
-        if len(node.args) != len(all_properties):
-             raise TypeError(f"Structure '{node.class_name}' expects {len(all_properties)} args for properties {all_properties}, got {len(node.args)}")
+        
+        # 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 prop, arg_expr in zip(all_properties, node.args):
-            val = self.visit(arg_expr)
-            instance.data[prop] = val
+        
+        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):
@@ -675,7 +695,7 @@ class Interpreter:
             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) in enumerate(method_node.args):
+        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:
@@ -698,15 +718,39 @@ class Interpreter:
         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:
-                raise AttributeError(f"Structure '{instance.class_def.name}' has no property '{node.property_name}'")
+                 # 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}'")
-        raise TypeError(f"'{node.instance_name}' is not a structure instance or dictionary.")
+
+        # 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])
@@ -750,8 +794,16 @@ class Interpreter:
         statements = parser.parse()
         for stmt in statements:
             self.visit(stmt)
-    def _get_class_properties(self, class_def: ClassDef) -> List[str]:
-        props = list(class_def.properties)
+    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.")
@@ -950,6 +1002,14 @@ class Interpreter:
         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))
@@ -1009,6 +1069,7 @@ class Interpreter:
         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:
@@ -1088,18 +1149,152 @@ class Interpreter:
         code = 0
         if node.code:
             code = self.visit(node.code)
-        import sys
-        sys.exit(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)
-        if len(node.args) != len(props):
-            raise TypeError(f"Thing '{node.class_name}' expects {len(props)} values, got {len(node.args)}")
+
+        # 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 prop, arg in zip(props, node.args):
-            instance.data[prop] = self.visit(arg)
+        
+        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)
@@ -1324,7 +1519,7 @@ class Interpreter:
                             self.wfile.write(str(e).encode())
                     except: pass
         server = HTTPServer(('0.0.0.0', port_val), ShellLiteHandler)
-        print(f"\n  ShellLite Server v0.03.4 is running!")
+        print(f"\n  ShellLite Server v0.04.1 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: 

shell_lite/js_compiler.py

@@ -149,12 +149,26 @@ class JSCompiler:
         code = f"class {node.name}{extends} {{\n"
         self.indentation += 1
         if node.properties:
-            props = node.properties
+            props = []
+            assigns = []
+            for p in node.properties:
+                if isinstance(p, tuple):
+                    name, default = p
+                    if default:
+                        # JS 6 supports defaults in args
+                        props.append(f"{name} = {self.visit(default)}")
+                    else:
+                        props.append(name)
+                    assigns.append(f"self.{name} = {name};")
+                else:
+                    props.append(p)
+                    assigns.append(f"self.{p} = {p};")
+            
             code += f"{self.indent()}constructor({', '.join(props)}) {{\n"
             self.indentation += 1
             if parent: code += f"{self.indent()}super();\n"
-            for p in props:
-                code += f"{self.indent()}self.{p} = {p};\n"
+            for assign in assigns:
+                 code += f"{self.indent()}{assign}\n"
             self.indentation -= 1
             code += f"{self.indent()}}}\n"
         for m in node.methods:

shell_lite/lexer.py

@@ -195,7 +195,7 @@ class Lexer:
                         'copy': 'COPY', 'paste': 'PASTE', 'clipboard': 'CLIPBOARD',
                         'press': 'PRESS', 'type': 'TYPE', 'click': 'CLICK', 'at': 'AT',
                         'notify': 'NOTIFY',
-                        'date': 'DATE', 'today': 'TODAY', 'after': 'AFTER', 'before': 'BEFORE',
+                        'date': 'ID', 'today': 'ID', 'after': 'AFTER', 'before': 'BEFORE',
                         'list': 'LIST', 'set': 'SET', 'unique': 'UNIQUE', 'of': 'OF',
                         'wait': 'WAIT',
                         'convert': 'CONVERT', 'json': 'JSON',
@@ -223,6 +223,9 @@ class Lexer:
                         'count': 'COUNT', 'many': 'MANY', 'how': 'HOW',
                         'field': 'FIELD', 'submit': 'SUBMIT', 'named': 'NAMED',
                         'placeholder': 'PLACEHOLDER',
+                        'app': 'APP', 'title': 'ID', 'size': 'ID',
+                        'column': 'ID', 'row': 'ID',
+                        'button': 'ID', 'heading': 'HEADING', 'text': 'ID',
                     }
                     token_type = keywords.get(value, 'ID')
                     self.tokens.append(Token(token_type, value, self.line_number, current_col))