shell-lite 0.5__py3-none-any.whl → 0.5.1__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.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/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.1) 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
@@ -199,6 +187,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))

shell_lite-0.5.1.dist-info/METADATA

@@ -0,0 +1,478 @@
+Metadata-Version: 2.1
+Name: shell-lite
+Version: 0.5.1
+Summary: A lightweight, English-like scripting language.
+Home-page: https://github.com/Shrey-N/ShellDesk
+Author: Shrey Naithani
+Author-email: Shrey Naithani <contact@shelllite.tech>
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: prompt-toolkit>=3.0.0
+
+<img src="assets/logo.png" align="right" width="250" alt="ShellLite Logo" />
+
+# ShellLite
+
+**The English-Like Programming Language**
+
+ShellLite is a modern programming language designed to prioritize human readability. It replaces complex syntax with natural English commands, making software development accessible and maintainable. With version 0.05.0, ShellLite now supports native compilation via LLVM alongside its interpreted mode.
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![Version](https://img.shields.io/badge/version-0.05.0-green.svg)]()
+
+---
+
+## Table of Contents
+
+- [Features](#features)
+- [Architecture](#architecture)
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Language Overview](#language-overview)
+- [Compilation](#compilation)
+- [The Three Pillars](#the-three-pillars)
+- [CLI Reference](#cli-reference)
+- [Project Structure](#project-structure)
+- [Documentation](#documentation)
+- [Ecosystem](#ecosystem)
+- [License](#license)
+
+---
+
+## Features
+
+| Feature | Description |
+|:--------|:------------|
+| **Natural Syntax** | Write code that reads like English |
+| **Dynamic Typing** | No type declarations required |
+| **Multi-Target Compilation** | Compile to LLVM, JavaScript, or Python |
+| **Python Integration** | Use any Python library via The Bridge |
+| **GUI Framework** | Build desktop apps with The Canvas |
+| **Package Manager** | Manage dependencies with The Universe |
+| **Web Framework** | Built-in HTTP server and routing |
+| **Interactive REPL** | Explore and test code interactively |
+
+---
+
+## Architecture
+
+```mermaid
+flowchart TB
+    subgraph Input
+        A[Source Code .shl]
+    end
+    
+    subgraph Frontend
+        B[Lexer]
+        C[Parser]
+        D[AST]
+    end
+    
+    subgraph Backend
+        E{Execution Mode}
+        F[Interpreter]
+        G[LLVM Codegen]
+        H[JS Compiler]
+        I[Python Transpiler]
+    end
+    
+    subgraph Output
+        J[Runtime Execution]
+        K[Native Binary]
+        L[JavaScript File]
+        M[Python File]
+    end
+    
+    A --> B --> C --> D --> E
+    E -->|interpret| F --> J
+    E -->|compile llvm| G --> K
+    E -->|compile js| H --> L
+    E -->|compile python| I --> M
+```
+
+### Compilation Pipeline
+
+```mermaid
+flowchart LR
+    subgraph Lexical Analysis
+        A[Source] --> B[Tokens]
+    end
+    
+    subgraph Parsing
+        B --> C[AST]
+    end
+    
+    subgraph Code Generation
+        C --> D[LLVM IR]
+        D --> E[Optimization]
+        E --> F[Native Code]
+    end
+```
+
+---
+
+## Installation
+
+### Via PyPI (Recommended)
+
+```bash
+pip install shell-lite
+```
+
+### From Source
+
+```bash
+git clone https://github.com/Shrey-N/ShellLite.git
+cd ShellLite
+pip install -e .
+```
+
+### Windows Installer
+
+Download the latest `shl.exe` from the [Releases](https://github.com/Shrey-N/ShellLite/releases) page.
+
+### Verify Installation
+
+```bash
+shl --version
+```
+
+---
+
+## Quick Start
+
+### Hello World
+
+Create a file named `hello.shl`:
+
+```
+say "Hello, World"
+```
+
+Run it:
+
+```bash
+shl hello.shl
+```
+
+### Interactive REPL
+
+```bash
+shl
+```
+
+```
+ShellLite REPL - English Syntax
+========================================
+>>> say "Hello"
+Hello
+>>> 5 + 5
+10
+>>> exit
+```
+
+---
+
+## Language Overview
+
+### Type System
+
+```mermaid
+graph TD
+    A[ShellLite Types] --> B[Number]
+    A --> C[String]
+    A --> D[Boolean]
+    A --> E[List]
+    A --> F[Dictionary]
+    A --> G[Function]
+    A --> H[Object]
+    A --> I[None]
+    
+    B --> B1[Integer]
+    B --> B2[Float]
+    D --> D1[yes / true]
+    D --> D2[no / false]
+```
+
+### Syntax Examples
+
+**Variables and Constants**
+```
+name = "Alice"
+age = 30
+const PI = 3.14159
+```
+
+**Control Flow**
+```
+if score > 90
+    say "Excellent"
+elif score > 70
+    say "Good"
+else
+    say "Keep trying"
+```
+
+**Functions**
+```
+to greet name
+    say "Hello, " + name
+    give "Greeted " + name
+
+result = greet "World"
+```
+
+**Classes**
+```
+thing Car
+    has speed = 0
+    
+    can accelerate amount
+        speed += amount
+        say "Speed: " + str(speed)
+
+my_car = new Car
+my_car.accelerate 50
+```
+
+### Natural Language Comparisons
+
+| Symbol | Natural Form |
+|:------:|:-------------|
+| `==` | `is`, `equals` |
+| `!=` | `is not` |
+| `>` | `is more than` |
+| `<` | `is less than` |
+| `>=` | `is at least` |
+| `<=` | `is at most` |
+
+---
+
+## Compilation
+
+### Compilation Targets
+
+```mermaid
+flowchart LR
+    A[script.shl] --> B{shl compile}
+    B -->|--target llvm| C[Native Binary]
+    B -->|--target js| D[JavaScript]
+    B -->|--target python| E[Python]
+```
+
+### Commands
+
+```bash
+# Compile to native code (default)
+shl compile script.shl
+
+# Compile to JavaScript
+shl compile script.shl --target js
+
+# Compile to Python
+shl compile script.shl --target python
+```
+
+### Performance Comparison
+
+| Mode | Relative Speed | Use Case |
+|:-----|:---------------|:---------|
+| Interpreted | 1x | Development |
+| Python Compiled | ~1.2x | Integration |
+| JavaScript | ~2-5x | Web deployment |
+| LLVM Native | ~10-50x | Production |
+
+---
+
+## The Three Pillars
+
+ShellLite v0.05.0 introduces three major features:
+
+```mermaid
+graph TB
+    subgraph "The Bridge"
+        A[Python Libraries]
+        A1[pandas]
+        A2[requests]
+        A3[numpy]
+        A --> A1
+        A --> A2
+        A --> A3
+    end
+    
+    subgraph "The Canvas"
+        B[GUI Framework]
+        B1[Windows]
+        B2[Dialogs]
+        B3[Controls]
+        B --> B1
+        B --> B2
+        B --> B3
+    end
+    
+    subgraph "The Universe"
+        C[Package Manager]
+        C1[Dependencies]
+        C2[GitHub Packages]
+        C3[shell-lite.toml]
+        C --> C1
+        C --> C2
+        C --> C3
+    end
+```
+
+### The Bridge - Python Integration
+
+Import and use any Python library directly:
+
+```
+use "pandas" as pd
+use "requests"
+
+data = pd.read_csv("data.csv")
+response = requests.get("https://api.example.com")
+```
+
+### The Canvas - GUI Applications
+
+Build native desktop applications:
+
+```
+app "My App" size 400, 300
+
+column
+    heading "Welcome"
+    button "Click Me" on_click handle_click
+
+to handle_click
+    alert "Button clicked!"
+```
+
+### The Universe - Package Management
+
+```bash
+# Initialize project
+shl init
+
+# Install dependencies
+shl install
+
+# Install from GitHub
+shl get username/repo
+```
+
+**shell-lite.toml**
+```toml
+[project]
+name = "my-app"
+version = "1.0.0"
+
+[dependencies]
+Shrey-N/shl-utils = "main"
+```
+
+---
+
+## CLI Reference
+
+| Command | Description |
+|:--------|:------------|
+| `shl <file.shl>` | Run a ShellLite script |
+| `shl` | Start the interactive REPL |
+| `shl compile <file>` | Compile to native code (LLVM) |
+| `shl compile <file> --target js` | Compile to JavaScript |
+| `shl compile <file> --target python` | Compile to Python |
+| `shl init` | Initialize a new project |
+| `shl install` | Install project dependencies |
+| `shl get <user/repo>` | Install a package from GitHub |
+| `shl fmt <file>` | Format a script |
+| `shl check <file>` | Lint a file (JSON output) |
+| `shl help` | Show help message |
+
+---
+
+## Project Structure
+
+```
+my-project/
+├── main.shl              # Entry point
+├── shell-lite.toml       # Project configuration
+├── modules/
+│   ├── utils.shl         # Utility functions
+│   └── api.shl           # API handlers
+├── tests/
+│   └── test_main.shl     # Test files
+└── public/
+    └── index.html        # Static files (web)
+```
+
+---
+
+## Documentation
+
+### Language Guide
+
+| Chapter | Topic |
+|:--------|:------|
+| [01](docs/01_Getting_Started.md) | Getting Started |
+| [02](docs/02_Language_Basics.md) | Language Basics |
+| [03](docs/03_Control_Flow.md) | Control Flow |
+| [04](docs/04_Data_Structures.md) | Data Structures |
+| [05](docs/05_Functions_and_OOP.md) | Functions and OOP |
+| [06](docs/06_Modules_and_StdLib.md) | Modules and Standard Library |
+| [07](docs/07_System_Mastery.md) | System Mastery |
+| [08](docs/08_Web_Development.md) | Web Development |
+
+### Advanced Topics
+
+| Chapter | Topic |
+|:--------|:------|
+| [09](docs/09_Advanced_Features.md) | Advanced Features |
+| [10](docs/10_Compilation_and_Performance.md) | Compilation and Performance |
+| [11](docs/11_Testing_and_Debugging.md) | Testing and Debugging |
+| [12](docs/12_API_Reference.md) | API Reference |
+
+### Guides and Resources
+
+| Chapter | Topic |
+|:--------|:------|
+| [13](docs/13_Security_Guide.md) | Security Guide |
+| [14](docs/14_Migration_Guide.md) | Migration Guide |
+| [15](docs/15_Troubleshooting.md) | Troubleshooting |
+| [16](docs/16_Examples_and_Tutorials.md) | Examples and Tutorials |
+| [17](docs/17_Best_Practices.md) | Best Practices |
+
+---
+
+## Ecosystem
+
+| Tool | Description | Link |
+|:-----|:------------|:-----|
+| **Book** | Language design, compiler construction, and architecture guide | [Book](https://books2read.com/b/mVpoXM) |
+| **ShellDesk** | Official IDE for ShellLite | [GitHub](https://github.com/Shrey-N/ShellDesk) |
+| **VS Code Extension** | Syntax highlighting and snippets | [Marketplace](https://marketplace.visualstudio.com/items?itemName=ShellLite.shelllite-hello) |
+| **Research Artifact** | Published on Zenodo by CERN | [Zenodo](https://github.com/Shrey-N/ShellDesk) |
+
+---
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines on how to contribute to ShellLite.
+
+## Security
+
+See [SECURITY.md](SECURITY.md) for reporting security vulnerabilities.
+
+## License
+
+MIT License - See [LICENSE](LICENSE) for details.
+
+---
+
+**ShellLite** - Making programming accessible through natural language.
+
+Created by Shrey Naithani

shell_lite-0.5.1.dist-info/RECORD

@@ -0,0 +1,20 @@
+shell_lite/__init__.py,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+shell_lite/ast_nodes.py,sha256=W2oefXuRjqnQybR5ZcdPU0qC5gxHZHcotQc3LAVDLM0,6129
+shell_lite/cli.py,sha256=14Kq1ohSXS3p-xdh0DPi7eXskUtSX81huSyGhktoOMA,250
+shell_lite/compiler.py,sha256=t2Imae9h03v3GIIKrCo16qCDDLKSxrpjrp83tv0SzUQ,24982
+shell_lite/interpreter.py,sha256=b2y2f-ric_LkIrXM2Z38xBsO2bCK0fuHzSX434621Lg,75869
+shell_lite/js_compiler.py,sha256=yEGIkkIvHGU7o1htHEqlQr6BE0wL35PtL5PssNld9fc,5606
+shell_lite/lexer.py,sha256=cNLk_N59a7eKQaQp7Mqcnxy1um64-QgtDEi2eAsAWKE,14913
+shell_lite/main.py,sha256=A4Yk97DHCap8Xs7dIsjy0pCkSiuzEnf1vO3gRF8tgSI,19877
+shell_lite/parser.py,sha256=qsR2wQUWjUPXbXgnmv8pmOgfX99lYYH6tpxKH3PEnfQ,88471
+shell_lite/parser_gbp.py,sha256=XRQ3AlNZvcq4nysMafF7rPIIcv_38vPG371vFS4QE-M,10168
+shell_lite/runtime.py,sha256=pSjBeA1dTQ-a94q3FLdv9lqZurdd6MJmfhFGHhOoQEM,16057
+shell_lite/llvm_backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+shell_lite/llvm_backend/builder.py,sha256=WjDj65DePu8LPpOpnjfS2XREy9vQt7aySAqRYvBMq5w,1434
+shell_lite/llvm_backend/codegen.py,sha256=sTpYxSdrOOqyjf9lj7TLQ5ZFOUM17RykL1QNeariZZM,15875
+shell_lite-0.5.1.dist-info/LICENSE,sha256=33eziKLPxbqGCqdHtEHAFe1KSOgqc0-jWUQmdgKq85Q,1092
+shell_lite-0.5.1.dist-info/METADATA,sha256=LkCUMAYeDRzm5N9_Q_DDDKQ3hKlSDweisCX4QZfJjq8,10447
+shell_lite-0.5.1.dist-info/WHEEL,sha256=hPN0AlP2dZM_3ZJZWP4WooepkmU9wzjGgCLCeFjkHLA,92
+shell_lite-0.5.1.dist-info/entry_points.txt,sha256=tglL8tjyPIh1W85j6zFpNZjMpQe_xC-k-7BOhHLWfxc,45
+shell_lite-0.5.1.dist-info/top_level.txt,sha256=hIln5ltrok_Mn3ijlQeqMFF6hHBHCyhzqCO7KL358cg,11
+shell_lite-0.5.1.dist-info/RECORD,,

{shell_lite-0.5.dist-info → shell_lite-0.5.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (72.1.0)
+Generator: bdist_wheel (0.46.3)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{shell_lite-0.5.dist-info → shell_lite-0.5.1.dist-info}/top_level.txt

@@ -1,2 +1 @@
 shell_lite
-tests

shell_lite-0.5.dist-info/METADATA

@@ -1,93 +0,0 @@
-Metadata-Version: 2.1
-Name: shell-lite
-Version: 0.5
-Summary: ShellLite: The English-Like Programming Language with LLVM Backend
-Home-page: https://github.com/Shrey-N/ShellDesk
-Author: Shrey Naithani
-Author-email: mrytshplays@gmail.com
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: llvmlite >=0.40.0
-Requires-Dist: colorama
-Requires-Dist: prompt-toolkit
-Requires-Dist: pygments
-Requires-Dist: pyinstaller
-
-<img src="assets/logo.png" align="right" width="250" alt="ShellLite Logo" />
-
-# ShellLite: The English-Like Programming Language
-# By Shrey Naithani
-ShellLite is a modern, interpreted programming language designed to prioritize human readability. It replaces complex syntax with natural English commands, making software development accessible and maintainable.
-
-## Version 0.04.0 (Polaris Update)
-
-This release transforms ShellLite from a scripting tool into a comprehensive platform with three major pillars:
-1. **The Bridge**: Import and use any Python library (pandas, requests, etc.) natively.
-2. **The Canvas**: Build native desktop GUI applications with declarative syntax.
-3. **The Universe**: Integrated package management for project dependencies.
-
-## Installation
-
-### Via PyPI (Recommended)
-You can install ShellLite directly from PyPI:
-```bash
-pip install shell-lite
-```
-
-### Windows Installer
-Download the latest `shl.exe` from the Releases page.
-
-## Compilation
-
-To compile ShellLite code to native machine code (LLVM IR):
-
-```bash
-shl compile script.shl
-```
-
-## Quick Start
-
-### 1. Hello World
-Save this as `hello.shl`:
-```shell-lite
-say "Hello, World"
-```
-Run it:
-```bash
-shl hello.shl
-```
-## Project Management
-
-Initialize a new project:
-```bash
-shl init
-```
-
-Install dependencies defined in `shell-lite.toml`:
-```bash
-shl install
-```
-
-## Ecosystem & Tools
-
-| Tool | Description | Link |
-| :--- | :--- | :--- |
-| **Book** | teaches cognitive friendly language design, controlled natural languages, compiler construction, forgiving parsing, FFI bridging, performance tuning, and provides full grammar, implementation, and architecture. | [Book](https://books2read.com/b/mVpoXM) |
-| **Research Artifact** | Published on Zenodo By CERN | [GitHub](https://github.com/Shrey-N/ShellDesk) |
-| **ShellDesk** | The official IDE for ShellLite. | [GitHub](https://github.com/Shrey-N/ShellDesk) |
-| **VS Code Extension** | Syntax highlighting and snippets. | [Marketplace](https://marketplace.visualstudio.com/items?itemName=ShellLite.shelllite-hello) / [OpenVSX](https://open-vsx.org/extension/shelllite/shelllite-hello) |
-| **Website** | Official website source code. | [GitHub](https://github.com/Shrey-N/ShellLite-Website) |
-
-## Documentation
-
-Full documentation is available directly in this repository:
-- [**Language Guide**](https://github.com/Shrey-N/ShellLite)
-- [**Examples**](https://github.com/Shrey-N/ShellLite/tree/main/examples)
-
-License: MIT
-Made by Shrey Naithani
-

shell_lite-0.5.dist-info/RECORD

@@ -1,33 +0,0 @@
-shell_lite/__init__.py,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-shell_lite/ast_nodes.py,sha256=W2oefXuRjqnQybR5ZcdPU0qC5gxHZHcotQc3LAVDLM0,6129
-shell_lite/cli.py,sha256=14Kq1ohSXS3p-xdh0DPi7eXskUtSX81huSyGhktoOMA,250
-shell_lite/compiler.py,sha256=t2Imae9h03v3GIIKrCo16qCDDLKSxrpjrp83tv0SzUQ,24982
-shell_lite/interpreter.py,sha256=-b4Oc-7SMeozbGo7-KQXQ-ip0t2VaG9naz68LiwN27U,75872
-shell_lite/js_compiler.py,sha256=yEGIkkIvHGU7o1htHEqlQr6BE0wL35PtL5PssNld9fc,5606
-shell_lite/lexer.py,sha256=JGqh89LQDCznUPo0YeZp4rm4B8SpshfIYfXdoXOy1Yc,13339
-shell_lite/main.py,sha256=9Up-AcE-J0VxMFai8iJ05ouGpBTCFN0AO9b6q7PVUZE,19880
-shell_lite/parser.py,sha256=qsR2wQUWjUPXbXgnmv8pmOgfX99lYYH6tpxKH3PEnfQ,88471
-shell_lite/parser_gbp.py,sha256=gvITN-5kgZa5fhH5jKITJuK2Rp9I7j8sACKQfppct3g,9640
-shell_lite/runtime.py,sha256=pSjBeA1dTQ-a94q3FLdv9lqZurdd6MJmfhFGHhOoQEM,16057
-shell_lite/llvm_backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-shell_lite/llvm_backend/builder.py,sha256=WjDj65DePu8LPpOpnjfS2XREy9vQt7aySAqRYvBMq5w,1434
-shell_lite/llvm_backend/codegen.py,sha256=sTpYxSdrOOqyjf9lj7TLQ5ZFOUM17RykL1QNeariZZM,15875
-tests/__init__.py,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
-tests/benchmark_driver.py,sha256=LBnreweO1x6K1-sw1Xf_vF8YogBqsKvIYBLuuSQUlLg,1526
-tests/compare_parsers.py,sha256=cC4aiKOQFmwcAYS2gcprjIX8rvvwciEN6ZL24YAvAuI,1113
-tests/debug_jit.py,sha256=ghJEnTc2eMqVGSexFyvoQEsGeuvixiUZKG7qZ1QX4Do,1877
-tests/generate_actual_graph.py,sha256=XLaG7a18avGlHvr-nbAMS6EQdTtmUKvwqjMwN2da08I,3329
-tests/generate_perf_graph.py,sha256=6xkDJvan3M6AzyHxo_BluBHNdXRKCTMq5UkLNRp_ikA,2621
-tests/generate_runtime_graph.py,sha256=GIcP8CIWLbrlHe-49ZfM6SOmuwcGsXd4x5A1F-I0d5g,2236
-tests/run_jit.py,sha256=T7QhoKWitoBNBWEU-chKCLXiuohbwb4uHazvUdljIYE,2358
-tests/test_gbp_standalone.py,sha256=p4EdLHLSPr7YwcY2ZcFeOTMeca-ICyIxlCthNbthagg,986
-tests/test_interpreter.py,sha256=04mYgjAw9DBbzM99rrEbRElCKamuJZDLnm2JdswGiw8,204
-tests/test_lexer.py,sha256=XTV0ixB8wSQ6RZpOpxa1Q8etkDKDMbv6mflN4IHAKzw,206
-tests/test_parser.py,sha256=c7DPLC7i7uCikKMJ099VJEYQzqesVZMSQ5ufNCTta8c,213
-tests/test_stdlib.py,sha256=wtCIeNkrnEp6v9DO1wMA3HPb1ANBzcveVKwLFJV81ho,204
-shell_lite-0.5.dist-info/LICENSE,sha256=33eziKLPxbqGCqdHtEHAFe1KSOgqc0-jWUQmdgKq85Q,1092
-shell_lite-0.5.dist-info/METADATA,sha256=Hx_YfK8NNMCuZr7rhfN1kJNLXl0buOYaN3HWSP4b-c0,3186
-shell_lite-0.5.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-shell_lite-0.5.dist-info/entry_points.txt,sha256=tglL8tjyPIh1W85j6zFpNZjMpQe_xC-k-7BOhHLWfxc,45
-shell_lite-0.5.dist-info/top_level.txt,sha256=LzIh1SJEY6HL6ZnmzrKTe2zGpFHgUgjV5XscPHHlu3Q,17
-shell_lite-0.5.dist-info/RECORD,,

tests/__init__.py

@@ -1 +0,0 @@
-

tests/benchmark_driver.py

@@ -1,43 +0,0 @@
-import os
-import time
-import subprocess
-import sys
-SHL_CMD = ["python", "shell_lite/main.py"]
-def run_benchmark():
-    print("Generating LLVM IR...")
-    subprocess.run(SHL_CMD + ["llvm", "tests/runtime_benchmark.shl"], check=True)
-    print("Compiling with Clang...")
-    subprocess.run(["clang", "tests/runtime_benchmark.ll", "-o", "tests/runtime_benchmark.exe", "-O3"], check=True)
-    print("\n[Running Native Executable...]")
-    start = time.perf_counter()
-    subprocess.run(["tests/runtime_benchmark.exe"], check=True)
-    native_time = time.perf_counter() - start
-    print(f"Native Time: {native_time:.4f}s")
-    print("\n[Running Interpreter (GBP)...]")
-    env = os.environ.copy()
-    env["USE_GBP"] = "1"
-    start = time.perf_counter()
-    subprocess.run(SHL_CMD + ["run", "tests/runtime_benchmark.shl"], env=env, check=True)
-    interp_time = time.perf_counter() - start
-    print(f"Interpreter Time: {interp_time:.4f}s")
-    print("\n[Running Python Equivalent...]")
-    py_code = """
-i = 0
-sum = 0
-count = 100000000
-while i < count:
-    sum = sum + 1
-    i = i + 1
-print("Done")
-print(sum)
-"""
-    start = time.perf_counter()
-    exec(py_code)
-    py_time = time.perf_counter() - start
-    print(f"Python Time: {py_time:.4f}s")
-    print("\n" + "="*30)
-    print(f"Native Speedup vs Interpreter: {interp_time/native_time:.2f}x")
-    print(f"Native Speedup vs Python:      {py_time/native_time:.2f}x")
-    print("="*30)
-if __name__ == "__main__":
-    run_benchmark()

tests/compare_parsers.py

@@ -1,31 +0,0 @@
-import sys
-import os
-import time
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
-from shell_lite.lexer import Lexer
-from shell_lite.parser import Parser
-from shell_lite.parser_gbp import GeometricBindingParser
-def benchmark(filename):
-    with open(filename, 'r') as f:
-        source = f.read()
-    long_source = source * 500 
-    print(f"Benchmarking on {len(long_source)} chars of code...")
-    lexer = Lexer(long_source)
-    tokens = lexer.tokenize()
-    tokens_copy = list(tokens)
-    start = time.perf_counter()
-    p_old = Parser(list(tokens)) # fresh copy? Parser consumes? yes
-    ast_old = p_old.parse()
-    end = time.perf_counter()
-    t_old = end - start
-    print(f"Recursive Descent: {t_old:.4f}s")
-    start = time.perf_counter()
-    p_new = GeometricBindingParser(list(tokens))
-    ast_new = p_new.parse()
-    end = time.perf_counter()
-    t_new = end - start
-    print(f"Geometric-Binding: {t_new:.4f}s")
-    diff = t_old / t_new if t_new > 0 else 0
-    print(f"Speedup: {diff:.2f}x")
-if __name__ == "__main__":
-    benchmark("tests/benchmark.shl")

tests/debug_jit.py

@@ -1,49 +0,0 @@
-import llvmlite.binding as llvm
-import sys
-def debug():
-    try:
-        llvm.initialize()
-        llvm.initialize_native_target()
-        llvm.initialize_native_asmprinter()
-        print("LLVM Initialized.")
-    except Exception as e:
-        print(f"Init Failed: {e}")
-        return
-    print("Available in llvm.binding:")
-    ops = [x for x in dir(llvm) if 'create' in x or 'jit' in x.lower() or 'engine' in x.lower()]
-    print(ops)
-    try:
-        mod = llvm.parse_assembly('define i32 @answer() { ret i32 42 }')
-        mod.verify()
-        print("Module parsed.")
-        target = llvm.Target.from_default_triple()
-        target_machine = target.create_target_machine()
-        engine = None
-        if hasattr(llvm, 'create_mcjit_compiler'):
-            print("Attempting MCJIT...")
-            try:
-                engine = llvm.create_mcjit_compiler(mod, target_machine)
-                print("MCJIT Created!")
-            except Exception as e:
-                print(f"MCJIT Failed: {e}")
-        if not engine and hasattr(llvm, 'create_execution_engine'):
-             print("Attempting create_execution_engine...")
-             try:
-                engine = llvm.create_execution_engine()
-                engine.add_module(mod)
-                print("ExecEngine Created!")
-             except Exception as e:
-                print(f"ExecEngine Failed: {e}")
-        if engine:
-            engine.finalize_object()
-            print("Engine Finalized.")
-            addr = engine.get_function_address("answer")
-            print(f"Function Address: {addr}")
-            import ctypes
-            cfunc = ctypes.CFUNCTYPE(ctypes.c_int)(addr)
-            res = cfunc()
-            print(f"Result: {res}")
-    except Exception as e:
-        print(f"Module/Engine Error: {e}")
-if __name__ == "__main__":
-    debug()

tests/generate_actual_graph.py

@@ -1,84 +0,0 @@
-import sys
-import os
-import time
-import matplotlib.pyplot as plt
-import subprocess
-import llvmlite.binding as llvm
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
-try:
-    from tests.run_jit import compile_and_run_jit
-except ImportError:
-    sys.path.append(os.path.join(os.path.dirname(__file__)))
-    from run_jit import compile_and_run_jit
-def run_benchmark():
-    counts = [1000000, 10000000, 50000000, 100000000, 200000000] 
-    t_interp = []
-    t_python = []
-    t_llvm = []
-    print("Running Massive Runtime Benchmark...")
-    for n in counts:
-        print(f"\n--- n = {n} ---")
-        if n <= 100000: # Reduced limit for massive scale run
-            shl_code = f"i = 0\nwhile i < {n}:\n    i = i + 1\n"
-            shl_file = f"tests/temp_{n}.shl"
-            with open(shl_file, "w") as f: f.write(shl_code)
-            env = os.environ.copy()
-            env["USE_GBP"] = "1"
-            start = time.perf_counter()
-            try:
-                subprocess.run(["python", "shell_lite/main.py", "run", shl_file], env=env, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)
-                dur = time.perf_counter() - start
-            except subprocess.CalledProcessError as e:
-                print(f"Interp failed: {e.stderr.decode()}")
-                dur = None
-            except Exception as e:
-                print(f"Interp failed: {e}")
-                dur = None
-            t_interp.append(dur)
-            if os.path.exists(shl_file): os.remove(shl_file)
-            if dur is not None:
-                print(f"Interpreter: {dur:.4f}s")
-            else:
-                 print("Interpreter: Failed")
-        else:
-            t_interp.append(None) 
-            print("Interpreter: Skipped (Too Slow)")
-        start = time.perf_counter()
-        i = 0
-        while i < n:
-            i += 1
-        dur = time.perf_counter() - start
-        t_python.append(dur)
-        print(f"Python: {dur:.6f}s")
-        jit_code = f"""
-        i = 0
-        count = {n}
-        while i < count:
-            i = i + 1
-        """
-        try:
-             _, dur, _ = compile_and_run_jit(jit_code)
-             if dur < 1e-7: dur = 1e-7 
-             t_llvm.append(dur)
-             print(f"LLVM JIT: {dur:.8f}s")
-        except Exception as e:
-             print(f"JIT Failed: {e}")
-             t_llvm.append(None)
-    plt.figure(figsize=(10, 6))
-    x_interp = [x for x, y in zip(counts, t_interp) if y is not None]
-    y_interp = [y for y in t_interp if y is not None]
-    if x_interp:
-        plt.plot(x_interp, y_interp, label='ShellLite Interpreter', marker='o', color='orange')
-    plt.plot(counts, t_python, label='Python Native', marker='s', color='green')
-    plt.plot(counts, t_llvm, label='LLVM JIT', marker='^', color='purple', linestyle='-')
-    plt.xlabel('Iterations')
-    plt.ylabel('Time (seconds)')
-    plt.title('GBP+LLVM Runtime Performance (Massive Scale)')
-    plt.yscale('log')
-    plt.legend()
-    plt.grid(True, which="both", ls="-", alpha=0.2)
-    output_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..', 'benchmark_final.png'))
-    plt.savefig(output_path)
-    print(f"Graph saved to {output_path}")
-if __name__ == "__main__":
-    run_benchmark()

tests/generate_perf_graph.py

@@ -1,68 +0,0 @@
-import sys
-import os
-import time
-import matplotlib.pyplot as plt
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
-from shell_lite.lexer import Lexer
-from shell_lite.parser import Parser
-from shell_lite.parser_gbp import GeometricBindingParser
-HAS_LLVM = False
-try:
-    from shell_lite.llvm_backend.codegen import LLVMCompiler
-    HAS_LLVM = True
-except ImportError:
-    print("LLVM backend (llvmlite) not found. Skipping LLVM benchmark.")
-def generate_large_file(lines=1000):
-    code = "x = 0\n"
-    for i in range(lines):
-        code += f"if x < {i}:\n"
-        code += f"    x = x + 1\n"
-    return code
-def run_benchmark():
-    sizes = [1000, 5000, 10000, 20000, 50000]
-    times_old = []
-    times_gbp = []
-    times_py = []
-    times_llvm = []
-    for size in sizes:
-        print(f"Benchmarking size: {size} lines...")
-        source_shl = generate_large_file(size)
-        source_py = source_shl.replace("x = x + 1", "x += 1")
-        start = time.perf_counter()
-        l = Lexer(source_shl)
-        toks = l.tokenize()
-        Parser(toks).parse()
-        times_old.append(time.perf_counter() - start)
-        start = time.perf_counter()
-        l = Lexer(source_shl)
-        toks = l.tokenize()
-        GeometricBindingParser(toks).parse()
-        times_gbp.append(time.perf_counter() - start)
-        start = time.perf_counter()
-        compile(source_py, '<string>', 'exec')
-        times_py.append(time.perf_counter() - start)
-        start = time.perf_counter()
-        if HAS_LLVM:
-            l = Lexer(source_shl)
-            toks = l.tokenize()
-            ast = GeometricBindingParser(toks).parse()
-            LLVMCompiler().compile(ast)
-            times_llvm.append(time.perf_counter() - start)
-        else:
-            times_llvm.append(0)
-    plt.figure(figsize=(10, 6))
-    plt.plot(sizes, times_old, label='Old Parser', marker='o', color='red')
-    plt.plot(sizes, times_gbp, label='GBP Parser', marker='s', color='blue')
-    plt.plot(sizes, times_py, label='Python Native', marker='^', color='green')
-    if HAS_LLVM and any(times_llvm):
-        plt.plot(sizes, times_llvm, label='LLVM Compile (via GBP)', marker='x', color='purple', linestyle='--')
-    plt.xlabel('Lines of Code')
-    plt.ylabel('Time (seconds)')
-    plt.title('Parsing/Compilation Speed vs Code Size')
-    plt.legend()
-    plt.grid(True)
-    output_path = os.path.join(os.path.dirname(__file__), 'benchmark_scaling.png')
-    plt.savefig(output_path)
-    print(f"Graph saved to {output_path}")
-if __name__ == "__main__":
-    run_benchmark()

tests/generate_runtime_graph.py

@@ -1,58 +0,0 @@
-import sys
-import os
-import time
-import matplotlib.pyplot as plt
-import subprocess
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
-def run_benchmark():
-    iterations = 1000000 # 1 Million
-    print(f"Benchmarking Runtime (Count: {iterations})...")
-    shl_code = f"""
-i = 0
-while i < {iterations}:
-    i = i + 1
-"""
-    shl_file = "tests/temp_loop.shl"
-    with open(shl_file, "w") as f:
-        f.write(shl_code)
-    env = os.environ.copy()
-    env["USE_GBP"] = "1"
-    start = time.perf_counter()
-    try:
-        subprocess.run(["python", "shell_lite/main.py", "run", shl_file], env=env, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)
-    except subprocess.CalledProcessError as e:
-        print(f"Interpreter Crash:\n{e.stderr.decode()}")
-        t_interp = 10.0 # Dummy
-    else:
-        t_interp = time.perf_counter() - start
-    print(f"Interpreter: {t_interp:.4f}s")
-    start = time.perf_counter()
-    i = 0
-    while i < iterations:
-        i = i + 1
-    t_python = time.perf_counter() - start
-    print(f"Python: {t_python:.4f}s")
-    t_llvm_est = t_python / 20.0 
-    print(f"LLVM (Est): {t_llvm_est:.4f}s")
-    labels = ['ShellLite Interpreter', 'Python Native', 'LLVM Native (Projected)']
-    times = [t_interp, t_python, t_llvm_est]
-    colors = ['orange', 'green', 'purple']
-    plt.figure(figsize=(10, 6))
-    bars = plt.bar(labels, times, color=colors)
-    plt.ylabel('Execution Time (seconds)')
-    plt.title(f'Runtime Speed Comparison ({iterations} Iterations)')
-    plt.yscale('log') # Log scale because difference is massive
-    for bar in bars:
-        height = bar.get_height()
-        plt.text(bar.get_x() + bar.get_width()/2., height,
-                 f'{height:.4f}s',
-                 ha='center', va='bottom')
-    plt.figtext(0.5, 0.01, 
-                "Note: Logarithmic Scale used due to massive speed difference.", 
-                ha="center", fontsize=10)
-    output_path = os.path.join(os.path.dirname(__file__), 'benchmark_runtime.png')
-    plt.savefig(output_path)
-    print(f"Graph saved to {output_path}")
-    if os.path.exists(shl_file): os.remove(shl_file)
-if __name__ == "__main__":
-    run_benchmark()

tests/run_jit.py

@@ -1,70 +0,0 @@
-import sys
-import os
-import time
-import ctypes
-import llvmlite.binding as llvm
-try:
-    from llvmlite.binding.orcjit import create_lljit_compiler, JITLibraryBuilder
-except ImportError:
-    import llvmlite.binding.orcjit as orc
-    create_lljit_compiler = orc.create_lljit_compiler
-    JITLibraryBuilder = orc.JITLibraryBuilder
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
-from shell_lite.lexer import Lexer
-from shell_lite.parser_gbp import GeometricBindingParser
-from shell_lite.llvm_backend.codegen import LLVMCompiler
-def compile_and_run_jit(source_code):
-    llvm.initialize_native_target()
-    llvm.initialize_native_asmprinter()
-    start_compile = time.perf_counter()
-    lexer = Lexer(source_code)
-    tokens = lexer.tokenize()
-    ast = GeometricBindingParser(tokens).parse()
-    compiler = LLVMCompiler()
-    ir_module = compiler.compile(ast)
-    llvm_ir = str(ir_module)
-    start_jit = time.perf_counter()
-    lljit = create_lljit_compiler()
-    builder = JITLibraryBuilder()
-    builder.add_ir(llvm_ir)
-    tracker = builder.link(lljit, "shell_lite_lib")
-    try:
-        addr = tracker["main"]
-    except KeyError:
-        try:
-             addr = tracker["_main"]
-        except KeyError:
-             print("Error: Could not find 'main' symbol.")
-             return 0, 0, -1
-    jit_time = time.perf_counter() - start_jit
-    cfunc = ctypes.CFUNCTYPE(ctypes.c_int)(addr)
-    start_run = time.perf_counter()
-    res = cfunc()
-    run_time = time.perf_counter() - start_run
-    return start_jit - start_compile, run_time, res
-if __name__ == "__main__":
-    code = """
-    sum = 0
-    i = 0
-    count = 10000000
-    while i < count:
-        sum = sum + 1
-        i = i + 1
-    print sum
-    """
-    print("Running JIT Speed Test (10M iterations)...")
-    try:
-        c_time, r_time, res = compile_and_run_jit(code)
-        print(f"Result: {res}")
-        print(f"JIT Exec Time: {r_time:.6f}s")
-        start_py = time.perf_counter()
-        s, i, c = 0, 0, 10000000
-        while i < c:
-            s += 1
-            i += 1
-        py_time = time.perf_counter() - start_py
-        print(f"Python Exec:   {py_time:.6f}s")
-        print(f"Speedup: {py_time / r_time:.2f}x")
-    except Exception as e:
-        import traceback
-        traceback.print_exc()

tests/test_gbp_standalone.py

@@ -1,37 +0,0 @@
-import sys
-import os
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
-from shell_lite.lexer import Lexer
-from shell_lite.parser_gbp import GeometricBindingParser
-def test_gbp(code, name):
-    print(f"--- Testing {name} ---")
-    print(f"Code:\n{code}")
-    lexer = Lexer(code)
-    tokens = lexer.tokenize()
-    parser = GeometricBindingParser(tokens)
-    parser.topology_scan()
-    print("\n[Phase 1] Topology Roots:")
-    for node in parser.root_nodes:
-        print(f"  {node}")
-        for child in node.children:
-            print(f"    -> {child}")
-    ast = parser.parse()
-    print("\n[Phase 2] AST:")
-    for node in ast:
-        print(f"  {node}")
-    print("------------------------\n")
-if __name__ == "__main__":
-    code1 = """
-x = 10
-if x > 5:
-    print x
-    y = x + 1
-"""
-    test_gbp(code1, "Basic If")
-    code2 = """
-to greet name:
-    print "Hello"
-    print name
-greet "Bob"
-"""
-    test_gbp(code2, "Function Def")

tests/test_interpreter.py

@@ -1,8 +0,0 @@
-import unittest
-class TestInterpreter(unittest.TestCase):
-    def test_visit_number(self):
-        pass
-    def test_visit_binop(self):
-        pass
-if __name__ == '__main__':
-    unittest.main()

tests/test_lexer.py

@@ -1,8 +0,0 @@
-import unittest
-class TestLexer(unittest.TestCase):
-    def test_lexer_initialization(self):
-        pass
-    def test_make_tokens(self):
-        pass
-if __name__ == '__main__':
-    unittest.main()

tests/test_parser.py

@@ -1,8 +0,0 @@
-import unittest
-class TestParser(unittest.TestCase):
-    def test_parser_initialization(self):
-        pass
-    def test_parse_expression(self):
-        pass
-if __name__ == '__main__':
-    unittest.main()

tests/test_stdlib.py

@@ -1,8 +0,0 @@
-import unittest
-class TestStdLib(unittest.TestCase):
-    def test_print_function(self):
-        pass
-    def test_input_function(self):
-        pass
-if __name__ == '__main__':
-    unittest.main()