shell-lite 0.5__py3-none-any.whl → 0.5.2__py3-none-any.whl

shell_lite/interpreter.py

@@ -1502,7 +1502,7 @@ class Interpreter:
                             self.wfile.write(str(e).encode())
                     except: pass
         server = ReusableHTTPServer(('0.0.0.0', port_val), ShellLiteHandler)
-        print(f"\n  ShellLite Server v0.04.6.8 is running!")
+        print(f"\n  ShellLite Server v0.5.2 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/lexer.py

@@ -15,6 +15,8 @@ class Lexer:
         self.current_char_index = 0
         self.line_number = 1
         self.indent_stack = [0]
+        self.bracket_depth = 0
+
     def tokenize(self) -> List[Token]:
         source = self._remove_multiline_comments(self.source_code)
         lines = source.split('\n')
@@ -27,21 +29,49 @@ class Lexer:
             if stripped_line.startswith('#'):
                 continue
             if indent_level > self.indent_stack[-1]:
-                self.indent_stack.append(indent_level)
-                self.tokens.append(Token('INDENT', '', self.line_number, indent_level + 1))
+                if self.bracket_depth == 0:
+                    self.indent_stack.append(indent_level)
+                    self.tokens.append(Token('INDENT', '', self.line_number, indent_level + 1))
             elif indent_level < self.indent_stack[-1]:
-                while indent_level < self.indent_stack[-1]:
-                    self.indent_stack.pop()
-                    self.tokens.append(Token('DEDENT', '', self.line_number, indent_level + 1))
-                if indent_level != self.indent_stack[-1]:
-                    raise IndentationError(f"Unindent does not match any outer indentation level on line {self.line_number}")
+                if self.bracket_depth == 0:
+                    while indent_level < self.indent_stack[-1]:
+                        self.indent_stack.pop()
+                        self.tokens.append(Token('DEDENT', '', self.line_number, indent_level + 1))
+                    if indent_level != self.indent_stack[-1]:
+                        raise IndentationError(f"Unindent does not match any outer indentation level on line {self.line_number}")
             self.tokenize_line(stripped_line, indent_level + 1)
-            self.tokens.append(Token('NEWLINE', '', self.line_number, len(line) + 1))
+            if self.bracket_depth == 0:
+                self.tokens.append(Token('NEWLINE', '', self.line_number, len(line) + 1))
         while len(self.indent_stack) > 1:
             self.indent_stack.pop()
             self.tokens.append(Token('DEDENT', '', self.line_number, 1))
         self.tokens.append(Token('EOF', '', self.line_number, 1))
+        # Post-process: Convert BEGIN/END to INDENT/DEDENT
+        self.tokens = self._convert_begin_end(self.tokens)
         return self.tokens
+    
+    def _convert_begin_end(self, tokens: List[Token]) -> List[Token]:
+        """Convert BEGIN/END keywords to INDENT/DEDENT for uniform parsing."""
+        result = []
+        i = 0
+        while i < len(tokens):
+            token = tokens[i]
+            if token.type == 'BEGIN':
+                # Remove preceding NEWLINE if present (since begin is on its own line)
+                if result and result[-1].type == 'NEWLINE':
+                    result.pop()
+                # Just add INDENT (the newline was already there from previous line)
+                result.append(Token('INDENT', '', token.line, token.column))
+            elif token.type == 'END':
+                # Add DEDENT
+                result.append(Token('DEDENT', '', token.line, token.column))
+                # Skip the NEWLINE after end if present
+                if i + 1 < len(tokens) and tokens[i + 1].type == 'NEWLINE':
+                    i += 1  # Skip the next NEWLINE
+            else:
+                result.append(token)
+            i += 1
+        return result
     def _remove_multiline_comments(self, source: str) -> str:
         result = []
         i = 0
@@ -150,6 +180,15 @@ class Lexer:
             }
             if char in single_char_tokens:
                 self.tokens.append(Token(single_char_tokens[char], char, self.line_number, current_col))
+                
+                # Track bracket depth here too
+                if char in '([{':
+                    self.bracket_depth += 1
+                elif char in ')]}':
+                    self.bracket_depth -= 1
+                    if self.bracket_depth < 0:
+                        self.bracket_depth = 0
+
                 pos += 1
                 continue
             if char.isalpha() or char == '_':
@@ -167,6 +206,7 @@ class Lexer:
                         'check': 'CHECK',
                         'unless': 'UNLESS', 'when': 'WHEN', 'otherwise': 'OTHERWISE',
                         'then': 'THEN', 'do': 'DO',
+                        'begin': 'BEGIN', 'end': 'END',
                         'print': 'PRINT', 'say': 'SAY', 'show': 'SAY',
                         'input': 'INPUT', 'ask': 'ASK',
                         'to': 'TO', 'can': 'TO',
@@ -246,8 +286,4 @@ class Lexer:
                     self.tokens.append(Token(token_type, value, self.line_number, current_col))
                     pos += len(value)
                     continue
-            if char in single_char_tokens:
-                self.tokens.append(Token(single_char_tokens[char], char, self.line_number, current_col))
-                pos += 1
-                continue
             raise SyntaxError(f"Illegal character '{char}' at line {self.line_number}")

shell_lite/main.py

@@ -150,7 +150,7 @@ def install_globally():
             return
         ps_cmd = f'$oldPath = [Environment]::GetEnvironmentVariable("Path", "User"); if ($oldPath -notlike "*ShellLite*") {{ [Environment]::SetEnvironmentVariable("Path", "$oldPath;{install_dir}", "User") }}'
         subprocess.run(["powershell", "-Command", ps_cmd], capture_output=True)
-        print(f"\n[SUCCESS] ShellLite (v0.04.6.8) is installed!")
+        print(f"\n[SUCCESS] ShellLite (v0.5.2) is installed!")
         print(f"Location: {install_dir}")
         print("\nIMPORTANT STEP REQUIRED:")
         print("1. Close ALL open terminal windows (CMD, PowerShell, VS Code).")

shell_lite/parser_gbp.py

@@ -11,6 +11,7 @@ class GeoNode:
     tokens: List[Token] = field(default_factory=list)
     children: List['GeoNode'] = field(default_factory=list)
     parent: Optional['GeoNode'] = None
+    
     def __repr__(self):
         return f"GeoNode(line={self.line}, indent={self.indent_level}, head={self.head_token.type})"
 class GeometricBindingParser:
@@ -39,19 +40,6 @@ class GeometricBindingParser:
         Phase 1: Scans tokens to build GeoNodes.
         Phase 2: Links them into a tree based on nesting.
         """
-        logical_lines = []
-        current_line_tokens = []
-        for token in self.tokens:
-            if token.type == 'NEWLINE':
-                if current_line_tokens:
-                    logical_lines.append(current_line_tokens)
-                current_line_tokens = []
-            elif token.type in ('INDENT', 'DEDENT', 'EOF'):
-                pass # logic handled below in a smarter way?
-            else:
-                current_line_tokens.append(token)
-        if current_line_tokens:
-             logical_lines.append(current_line_tokens)
         node_stack: List[GeoNode] = [] # The active parents
         current_tokens_accumulator = []
         current_node: Optional[GeoNode] = None
@@ -103,6 +91,10 @@ class GeometricBindingParser:
             return self.bind_return(node)
         elif head_type == 'REPEAT':
             return self.bind_repeat(node)
+        elif head_type == 'START':
+            return self.bind_start(node)
+        elif head_type == 'LISTEN':
+            return self.bind_listen(node)
         elif head_type == 'ID':
             if any(t.type == 'ASSIGN' for t in node.tokens):
                 return self.bind_assignment(node)
@@ -151,6 +143,17 @@ class GeometricBindingParser:
         return Assign(name, value)
     def bind_expression_stmt(self, node: GeoNode) -> Any:
         return self.parse_expr_iterative(node.tokens)
+    def bind_start(self, node: GeoNode) -> Listen:
+        # 'start website' -> Listen(8080)
+        # We could parse args if needed, but for now we assume default
+        return Listen(Number(8080))
+    def bind_listen(self, node: GeoNode) -> Listen:
+        # 'listen 8080' or 'listen port 8080'
+        expr_tokens = self._extract_expr_tokens(node.tokens, start=1)
+        if expr_tokens and expr_tokens[0].type == 'PORT':
+             expr_tokens.pop(0)
+        port = self.parse_expr_iterative(expr_tokens)
+        return Listen(port)
     def bind_func(self, node: GeoNode) -> FunctionDef:
         start = 1
         if node.tokens[0].type == 'DEFINE': start = 2
@@ -199,6 +202,31 @@ class GeometricBindingParser:
                 values.append(Number(int(t.value) if '.' not in t.value else float(t.value)))
             elif t.type == 'STRING':
                 values.append(String(t.value))
+            elif t.type == 'LBRACKET':
+                # Consumed nested list
+                depth = 1
+                j = i + 1
+                elements_tokens = []
+                current_elem = []
+                while j < len(tokens):
+                    if tokens[j].type == 'LBRACKET': depth += 1
+                    elif tokens[j].type == 'RBRACKET': depth -= 1
+                    
+                    if depth == 0:
+                        if current_elem: elements_tokens.append(current_elem)
+                        break
+                    
+                    if tokens[j].type == 'COMMA' and depth == 1:
+                        elements_tokens.append(current_elem)
+                        current_elem = []
+                    else:
+                        current_elem.append(tokens[j])
+                    j += 1
+                
+                # Parse elements
+                items = [self.parse_expr_iterative(elem) for elem in elements_tokens if elem]
+                values.append(ListVal(items))
+                i = j # Advance past list
             elif t.type == 'ID':
                 if i+1 < len(tokens) and tokens[i+1].type == 'LPAREN':
                     values.append(VarAccess(t.value))