enlang 2.0.0__py3-none-any.whl

enlang-2.0.0.dist-info/METADATA

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: enlang
+Version: 2.0.0
+Summary: The Universal Natural English Programming Language Transpiler & Compiler Engine
+Home-page: https://github.com/Aero99op/enlang
+Author: Spandan Prayas Patra
+Author-email: Spandan Prayas Patra <spandan@enlang.org>
+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
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-python
+
+# EnLang — The Universal Natural English Programming Language
+### *Build Full-Stack Applications Using Natural English*
+
+[![Version](https://img.shields.io/badge/version-2.0.0--Enterprise-indigo.svg)](https://github.com/Aero99op/enlang)
+[![License](https://img.shields.io/badge/license-Proprietary%20%2F%20Enterprise-blue.svg)](LICENSE)
+[![Tests](https://img.shields.io/badge/tests-154%2F154%20PASS-success.svg)](tests/)
+
+Created and Authored by **Spandan Prayas Patra**.
+
+---
+
+## 🌟 Overview
+**EnLang** is a deterministic, universal multi-target programming language and transpilation engine that converts natural English into 1:1 clean, production-grade native targets:
+
+- **`.enlg`** ➔ Core Backend Logic & Algorithms (Python 3)
+- **`.enlgf`** ➔ Structural Frontend Markup (HTML5)
+- **`.enlgd`** ➔ Styling & Design Systems (CSS3)
+- **`.enlgs`** ➔ Client Scripting & DOM Logic (JavaScript ES6+)
+- **`.enlgdb`** ➔ Database Schemas & Queries (SQL)
+
+---
+
+## 🚀 Official Installation Methods
+
+EnLang is distributed as a compiled distribution engine. You can install EnLang globally on your system using either of the following official methods:
+
+### 1️⃣ Method 1: One-Click Windows GUI Installer (Recommended)
+Download and launch the official compiled setup wizard:
+👉 **[Download EnLangInstaller.exe](https://raw.githubusercontent.com/Aero99op/enlang/main/EnLangInstaller.exe)**
+
+*The GUI Installer automatically extracts the core runtime binaries to `%USERPROFILE%\.enlang\` and registers the system `PATH` environment variable.*
+
+### 2️⃣ Method 2: CLI Package Installation (`pip`)
+Install EnLang directly into your Python CLI environment using `pip`:
+
+```bash
+pip install enlang
+```
+
+---
+
+## 🛠️ Global CLI Tooling
+
+Once installed via GUI or `pip`, open any command prompt or terminal and use:
+
+```bash
+enlang run main.enlg          # Compiles and executes EnLang program
+enlang check main.enlg        # Runs static analysis & syntax linter
+enlang debug main.enlg        # Launches step-by-step interactive debugger
+enlang build index.enlgf      # Transpiles source to native target file (.py, .html, .css, .js, .sql)
+enlang server --port 8000     # Launches zero-config EnLang HTTP web server
+epm init                      # Initializes a new EnLang project package
+```
+
+---
+
+## 💡 Syntax Showcase
+
+```enlang
+define text username as "Spandan"
+
+function numbers using n:
+    if n is greater than 10 then:
+        return
+    display n
+    call numbers with (n plus 1)
+
+start numbers from 1
+```
+
+---
+
+## 📚 Official Specification & Book
+The official specification book **"EnLang for Developers: Enterprise Specification Edition (v2.0)"** is available in this repository:
+- 📄 [ENLANG_FOR_DEVELOPERS_BOOK.pdf](ENLANG_FOR_DEVELOPERS_BOOK.pdf)
+
+---
+
+## 📜 Distribution & Rights
+Copyright © 2026 Spandan Prayas Patra. All rights reserved.  
+Distributed via official GUI Standalone Binary & PyPI Package Manager (`pip`).

enlang-2.0.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+enlang.py,sha256=DJTRbOuaLB4e6tfWcy8D482rARgQ0dMHT4OQqtJeUlk,5380
+gui_installer.py,sha256=xHTbeEnWq8Smnu-ltq_pLiODNkfjIfZfAG0cxxiXH1M,11380
+installer.py,sha256=LpCiXbtAv2wsJ4Y_-04eStCS9ayPLeWMcLQ65lFXQAs,5290
+enlang_core/__init__.py,sha256=dYQ8sIdRcnRUgghwKtjYsna4U-0r1npQttM9RO4U6OI,267
+enlang_core/checker.py,sha256=ZqQPCzaIGRZJbenYzby1hWHhuQIkFa48dDuUxf2tf4w,5653
+enlang_core/cli.py,sha256=0SqgKFsKoXT0TJGCIdfF3h-mOFRKs0f4SjacbZ4him0,5762
+enlang_core/debugger.py,sha256=oPQEvufDGD-zsYf6c5_aqc1FGJbqBwR-QEX7mnywHe8,5779
+enlang_core/epm.py,sha256=26hN0GlowSidu8mCUka7-euR-Hd1BtVBVgkqHbowTYA,4884
+enlang_core/grammar.py,sha256=eYWHq8L6bdRz9ZOfv2cdojKQ8U1LzbUEaCqJ9PfxWuU,58641
+enlang_core/interpreter.py,sha256=ES8RVXSQW0hbLr1pfWmWaRkk8D3ObKgeDHxUyD0qGeM,1910
+enlang_core/nlp_engine.py,sha256=mHWFtBKU_mbMarYrNJDqe2QMLyZq4kUwuqiH8U8V6qI,4879
+enlang_core/transpiler.py,sha256=fVw-BRdmetTZydpw8MB_sYO22SaPQH6YJir243XBMTM,40573
+enlang_core/web_server.py,sha256=L4HyhkSkYsrJJKBe65itAhsuRCoSsNhWwbjoB6ppXrs,9269
+enlang-2.0.0.dist-info/METADATA,sha256=Jm4dQ19azLcz72rprnGtQo14qN_chiZ99B2PfG--tJg,3591
+enlang-2.0.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+enlang-2.0.0.dist-info/entry_points.txt,sha256=MLXJeS95E76TSCZcV1amZsz5-2ZkO-eG_hEjr5xtWz4,75
+enlang-2.0.0.dist-info/top_level.txt,sha256=cztgUOkeIwT6vw4FRFBW35mrhEUKW0jn6MEbH8T8n_M,43
+enlang-2.0.0.dist-info/RECORD,,

enlang-2.0.0.dist-info/WHEEL

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

enlang-2.0.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+enlang = enlang_core.cli:main
+epm = enlang_core.epm:main

enlang-2.0.0.dist-info/top_level.txt

@@ -0,0 +1,4 @@
+enlang
+enlang_core
+gui_installer
+installer

enlang.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+"""
+EnLang Command Line Interface (CLI)
+Natural English Programming Language Runner & Tooling.
+Supports .enlg (Normal), .enlgd (Design UI), .enlgs (Script Automation), and .enlgdb (Database).
+"""
+
+import sys
+import os
+import argparse
+from enlang_core import EnLangInterpreter, EnLangTranspiler, __version__
+
+SUPPORTED_EXTENSIONS = ['.enlg', '.enlgf', '.enlgd', '.enlgs', '.enlgdb', '.enl']
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="enlang",
+        description="EnLang - Universal Natural English Programming Language (.enlg, .enlgd, .enlgs, .enlgdb)"
+    )
+    subparsers = parser.add_subparsers(dest="command", help="Available subcommands")
+
+    # Command: run
+    run_parser = subparsers.add_parser("run", help="Run an EnLang (.enlg / .enlgd / .enlgs / .enlgdb) script directly")
+    run_parser.add_argument("filename", help="Path to EnLang file")
+    run_parser.add_argument("--show-python", action="store_true", help="Print transpiled Python code before running")
+
+    # Command: build
+    build_parser = subparsers.add_parser("build", help="Transpile EnLang script to a Python (.py) file")
+    build_parser.add_argument("filename", help="Path to EnLang file")
+    build_parser.add_argument("-o", "--output", help="Output .py file path")
+
+    # Command: check
+    check_parser = subparsers.add_parser("check", help="Perform static analysis and linting on EnLang source file")
+    check_parser.add_argument("filename", help="Path to EnLang file")
+
+    # Command: debug
+    debug_parser = subparsers.add_parser("debug", help="Launch interactive step-by-step debugger")
+    debug_parser.add_argument("filename", help="Path to EnLang file")
+
+    # Command: repl / shell
+    subparsers.add_parser("repl", help="Start interactive EnLang English REPL shell")
+    subparsers.add_parser("shell", help="Start interactive EnLang English REPL shell")
+
+    # Command: version
+    subparsers.add_parser("version", help="Show EnLang version")
+
+    args = parser.parse_args()
+
+    interpreter = EnLangInterpreter()
+    transpiler = EnLangTranspiler()
+
+    if args.command == "run":
+        if not os.path.exists(args.filename):
+            print(f"Error: File '{args.filename}' not found.", file=sys.stderr)
+            sys.exit(1)
+
+        with open(args.filename, "r", encoding="utf-8") as f:
+            source = f.read()
+
+        if args.show_python:
+            py_code = transpiler.transpile(source, file_path=args.filename)
+            print(f"--- Generated Python Code ({args.filename}) ---")
+            print(py_code)
+            print("--- Execution Output ---")
+
+        success, stdout, stderr, _ = interpreter.run_code(source, file_path=args.filename)
+        if stdout:
+            print(stdout, end="")
+        if stderr:
+            print(stderr, file=sys.stderr, end="")
+        sys.exit(0 if success else 1)
+
+    elif args.command == "build":
+        if not os.path.exists(args.filename):
+            print(f"Error: File '{args.filename}' not found.", file=sys.stderr)
+            sys.exit(1)
+
+        with open(args.filename, "r", encoding="utf-8") as f:
+            source = f.read()
+
+        py_code = transpiler.transpile(source, file_path=args.filename)
+        out_path = args.output if args.output else os.path.splitext(args.filename)[0] + ".py"
+
+        with open(out_path, "w", encoding="utf-8") as f:
+            f.write(py_code)
+
+        print(f"Successfully compiled '{args.filename}' -> '{out_path}'")
+
+    elif args.command == "check":
+        from enlang_core.checker import check_file
+        ok = check_file(args.filename)
+        sys.exit(0 if ok else 1)
+
+    elif args.command == "debug":
+        from enlang_core.debugger import debug_file
+        debug_file(args.filename)
+        sys.exit(0)
+
+    elif args.command in ["repl", "shell"]:
+        start_repl(interpreter)
+
+    elif args.command == "version":
+        print(f"EnLang Version {__version__} (NLP Engine & Multi-Extension Support: .enlg, .enlgd, .enlgs, .enlgdb)")
+
+    else:
+        # Default behavior if file passed directly without subcommand
+        if len(sys.argv) > 1 and os.path.exists(sys.argv[1]):
+            success, stdout, stderr, _ = interpreter.run_file(sys.argv[1])
+            if stdout:
+                print(stdout, end="")
+            if stderr:
+                print(stderr, file=sys.stderr, end="")
+            sys.exit(0 if success else 1)
+        else:
+            parser.print_help()
+
+def start_repl(interpreter: EnLangInterpreter):
+    """Starts the interactive EnLang English Shell with NLP intent parsing."""
+    print(f"EnLang Interactive NLP English Shell v{__version__}")
+    print("Supports natural English phrasing & NLP commands. Type 'exit' to quit.\n")
+
+    repl_globals = {}
+    while True:
+        try:
+            line = input("enl> ")
+            if line.strip().lower() in ["exit", "quit", "exit()"]:
+                print("Bye!")
+                break
+            if not line.strip():
+                continue
+
+            success, stdout, stderr, py_code = interpreter.run_code(line, custom_globals=repl_globals)
+            if stdout:
+                print(stdout, end="")
+            if stderr:
+                print(f"[Error] {stderr}", end="")
+        except (KeyboardInterrupt, EOFError):
+            print("\nExiting EnLang shell. Bye!")
+            break
+
+if __name__ == "__main__":
+    main()

enlang_core/__init__.py

@@ -0,0 +1,10 @@
+"""
+EnLang Core Package
+Natural English Programming Language Transpiler, Interpreter & Domain Helpers.
+"""
+
+from .transpiler import EnLangTranspiler
+from .interpreter import EnLangInterpreter
+
+__version__ = "1.0.0"
+__all__ = ["EnLangTranspiler", "EnLangInterpreter"]

enlang_core/checker.py

@@ -0,0 +1,162 @@
+"""
+EnLang Syntax Checker & Linter
+==============================
+Performs static analysis and linting on EnLang source files (.enlg, .enlgf, .enlgd, .enlgs, .enlgdb)
+without executing them.
+
+Checks:
+  1. Indentation & Block boundary formatting (4-space rule)
+  2. Trailing colon (:) on block headers
+  3. Matched block closures (end match, end interface)
+  4. Unclosed string literals
+  5. Unsupported or ambiguous phrase warnings (e.g., 'is bigger than')
+"""
+
+import sys
+import re
+import os
+
+class Diagnostic:
+    def __init__(self, line_no: int, message: str, level: str = "ERROR", suggestion: str = ""):
+        self.line_no = line_no
+        self.message = message
+        self.level = level  # ERROR, WARNING, INFO
+        self.suggestion = suggestion
+
+    def __str__(self):
+        prefix = f"[{self.level}] Line {self.line_no}: {self.message}"
+        if self.suggestion:
+            prefix += f" (Suggestion: {self.suggestion})"
+        return prefix
+
+def _check_line(idx: int, raw_line: str, line: str, diagnostics: list):
+    lstripped = raw_line.lstrip()
+    indent_len = len(raw_line) - len(lstripped)
+
+    # Check 1: Indentation (Must be multiple of 4 spaces if indented)
+    if indent_len % 4 != 0:
+        diagnostics.append(Diagnostic(
+            idx,
+            f"Indentation is {indent_len} spaces. EnLang requires multiples of 4 spaces.",
+            level="WARNING",
+            suggestion=f"Adjust indentation to {(indent_len // 4 + 1) * 4} spaces"
+        ))
+
+    # Check 2: Unclosed string literal
+    double_quotes = line.count('"') - line.count('\\"')
+    single_quotes = line.count("'") - line.count("\\'")
+    if double_quotes % 2 != 0 or single_quotes % 2 != 0:
+        diagnostics.append(Diagnostic(
+            idx,
+            "Unclosed string literal detected.",
+            level="ERROR",
+            suggestion="Ensure string quotes are closed properly"
+        ))
+
+    # Check 3: Block header missing trailing colon
+    block_headers = (
+        r'^\s*(?:if|otherwise\s+if|elif|else|repeat|for|while|until|function|func|action|task|procedure|process|class|interface|match|switch|try|except|finally|style|on\s+screen|animate)\b'
+    )
+    if re.search(block_headers, raw_line, re.IGNORECASE):
+        if not line.endswith(":") and not re.search(r'\b(?:then|do)\b', line, re.IGNORECASE):
+            diagnostics.append(Diagnostic(
+                idx,
+                "Block header missing trailing colon ':'.",
+                level="ERROR",
+                suggestion="Add a colon ':' at the end of the line"
+            ))
+
+    # Check 4: Unsupported English phrases
+    invalid_phrases = [
+        (r'\bis bigger than\b', "Use 'is greater than' instead of 'is bigger than'"),
+        (r'\bis same as\b', "Use 'is equal to' instead of 'is same as'"),
+        (r'\bassign\b.+\bto\b', "Use 'set <var> to <val>' or 'store <val> in <var>'"),
+        (r'\bput\b.+\binside\b', "Use 'store <val> in <var>'"),
+    ]
+    for pattern, sugg in invalid_phrases:
+        if re.search(pattern, line, re.IGNORECASE):
+            diagnostics.append(Diagnostic(
+                idx,
+                "Unsupported natural phrase detected in statement.",
+                level="ERROR",
+                suggestion=sugg
+            ))
+
+def check_syntax(code: str, file_path: str = "main.enlg") -> list:
+    diagnostics = []
+    lines = code.splitlines()
+
+    in_match = False
+    in_interface = False
+
+    for idx, raw_line in enumerate(lines, start=1):
+        line = raw_line.strip()
+        if not line or line.startswith("#") or line.startswith("//"):
+            continue
+
+        _check_line(idx, raw_line, line, diagnostics)
+
+        # Block tracking
+        if re.match(r'^\s*(?:match|switch)\b', line, re.IGNORECASE):
+            in_match = True
+        elif re.match(r'^\s*end\s+match\b', line, re.IGNORECASE):
+            in_match = False
+
+        if re.match(r'^\s*interface\b', line, re.IGNORECASE):
+            in_interface = True
+        elif re.match(r'^\s*end\s+interface\b', line, re.IGNORECASE):
+            in_interface = False
+
+    if in_match:
+        diagnostics.append(Diagnostic(
+            len(lines),
+            f"Unclosed 'match' block in {file_path}. Missing 'end match'.",
+            level="ERROR",
+            suggestion="Add 'end match' at the end of the match block"
+        ))
+
+    if in_interface:
+        diagnostics.append(Diagnostic(
+            len(lines),
+            f"Unclosed 'interface' block in {file_path}. Missing 'end interface'.",
+            level="ERROR",
+            suggestion="Add 'end interface' at the end of the interface block"
+        ))
+
+    return diagnostics
+
+def check_file(file_path: str):
+    if not os.path.exists(file_path):
+        print(f"[ERROR] File '{file_path}' not found.")
+        return False
+
+    with open(file_path, "r", encoding="utf-8") as f:
+        code = f.read()
+
+    diagnostics = check_syntax(code, file_path)
+
+    print("=" * 65)
+    print(f"  EnLang Syntax Checker & Linter  —  {file_path}")
+    print("=" * 65)
+
+    if not diagnostics:
+        print("  [PASS] No syntax errors or warnings found! Clean file.")
+        print("=" * 65)
+        return True
+
+    errors = [d for d in diagnostics if d.level == "ERROR"]
+    warnings = [d for d in diagnostics if d.level == "WARNING"]
+
+    for d in diagnostics:
+        print(f"  {d}")
+
+    print("=" * 65)
+    print(f"  Result: {len(errors)} Error(s), {len(warnings)} Warning(s)")
+    print("=" * 65)
+    return len(errors) == 0
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1:
+        check_file(sys.argv[1])
+    else:
+        print("Usage: python -m enlang_core.checker <filename.enlg>")

enlang_core/cli.py

@@ -0,0 +1,181 @@
+"""
+EnLang Main CLI Interface
+=========================
+Command-line driver for running, building, and serving EnLang applications.
+
+Commands:
+  enlang run <file>          Compiles & executes an EnLang file (.enlg, .enlgf, .enlgd, .enlgs, .enlgdb)
+  enlang build <file>        Transpiles EnLang source to native code file
+  enlang server [--port P]   Launches zero-config EnLang HTTP Web Server
+  enlang version             Displays installed EnLang version
+  enlang help                Shows usage instructions
+"""
+
+import sys
+import os
+import argparse
+
+VERSION = "2.0.0 — Enterprise Specification Edition"
+
+def main():
+    if len(sys.argv) < 2:
+        print_help()
+        sys.exit(0)
+
+    cmd = sys.argv[1].lower()
+
+    if cmd in ("--version", "-v", "version"):
+        print(f"EnLang Compiler Version {VERSION}")
+        print("Author: Spandan Prayas Patra")
+        sys.exit(0)
+
+    if cmd in ("--help", "-h", "help"):
+        print_help()
+        sys.exit(0)
+
+    if cmd == "run":
+        if len(sys.argv) < 3:
+            print("Error: Please specify a file to run.")
+            print("Usage: enlang run <filename.enlg|enlgf|enlgd|enlgs|enlgdb>")
+            sys.exit(1)
+        file_path = sys.argv[2]
+        run_file(file_path)
+
+    elif cmd == "build":
+        if len(sys.argv) < 3:
+            print("Error: Please specify a file to build.")
+            print("Usage: enlang build <filename.enlg|enlgf|enlgd|enlgs|enlgdb>")
+            sys.exit(1)
+        file_path = sys.argv[2]
+        build_file(file_path)
+
+    elif cmd in ("check", "lint"):
+        if len(sys.argv) < 3:
+            print("Error: Please specify a file to check.")
+            print("Usage: enlang check <filename.enlg>")
+            sys.exit(1)
+        file_path = sys.argv[2]
+        try:
+            from .checker import check_file
+        except ImportError:
+            from enlang_core.checker import check_file
+        check_file(file_path)
+
+    elif cmd in ("debug", "dbg"):
+        if len(sys.argv) < 3:
+            print("Error: Please specify a file to debug.")
+            print("Usage: enlang debug <filename.enlg>")
+            sys.exit(1)
+        file_path = sys.argv[2]
+        try:
+            from .debugger import debug_file
+        except ImportError:
+            from enlang_core.debugger import debug_file
+        debug_file(file_path)
+
+    elif cmd == "server":
+        port = 8000
+        if "--port" in sys.argv:
+            try:
+                idx = sys.argv.index("--port")
+                port = int(sys.argv[idx + 1])
+            except (ValueError, IndexError):
+                print("Warning: Invalid port specified, using default port 8000.")
+        
+        print(f"[INFO] Launching EnLang Web Server on port {port}...")
+        try:
+            from .web_server import start_enlang_server
+            start_enlang_server(port)
+        except ImportError:
+            from enlang_core.web_server import start_enlang_server
+            start_enlang_server(port)
+
+    else:
+        # Fallback: Treat sys.argv[1] as a file to run directly (e.g. enlang app.enlg)
+        file_path = sys.argv[1]
+        if os.path.exists(file_path):
+            run_file(file_path)
+        else:
+            print(f"Unknown command or file not found: {cmd}")
+            print_help()
+            sys.exit(1)
+
+def run_file(file_path: str):
+    if not os.path.exists(file_path):
+        print(f"Error: File '{file_path}' not found.")
+        sys.exit(1)
+
+    try:
+        from .interpreter import EnLangInterpreter
+    except ImportError:
+        from enlang_core.interpreter import EnLangInterpreter
+
+    interp = EnLangInterpreter()
+    with open(file_path, "r", encoding="utf-8") as f:
+        code = f.read()
+
+    ok, stdout, stderr, _ = interp.run_code(code, file_path=file_path)
+    if stdout.strip():
+        print(stdout)
+    if not ok:
+        print(f"[ERROR] EnLang Runtime Exception:\n{stderr}", file=sys.stderr)
+        sys.exit(1)
+
+def build_file(file_path: str):
+    if not os.path.exists(file_path):
+        print(f"Error: File '{file_path}' not found.")
+        sys.exit(1)
+
+    try:
+        from .transpiler import EnLangTranspiler
+    except ImportError:
+        from enlang_core.transpiler import EnLangTranspiler
+
+    t = EnLangTranspiler()
+    with open(file_path, "r", encoding="utf-8") as f:
+        code = f.read()
+
+    transpiled = t.transpile(code, file_path=file_path)
+
+    ext = os.path.splitext(file_path)[1].lower()
+    target_ext_map = {
+        ".enlg": ".py",
+        ".enlgf": ".html",
+        ".enlgd": ".css",
+        ".enlgs": ".js",
+        ".enlgdb": ".sql"
+    }
+    target_ext = target_ext_map.get(ext, ".py")
+    out_file = os.path.splitext(file_path)[0] + target_ext
+
+    with open(out_file, "w", encoding="utf-8") as f:
+        f.write(transpiled)
+
+    print(f"[SUCCESS] Transpiled '{file_path}' -> '{out_file}'")
+
+def print_help():
+    print("""
+EnLang — Universal Natural English Compiler CLI (v2.0)
+
+USAGE:
+  enlang <command> [options]
+
+COMMANDS:
+  run <file>          Compiles & executes an EnLang file (.enlg, .enlgf, .enlgd, .enlgs, .enlgdb)
+  build <file>        Transpiles EnLang source file into native target code file (.py, .html, .css, .js, .sql)
+  check <file>        Performs static analysis and linting without execution
+  debug <file>        Launches interactive step-by-step debugger with live variable inspection
+  server [--port N]   Launches EnLang HTTP Web Server on specified port (default: 8000)
+  version             Displays installed compiler version & author info
+  help                Shows this usage manual
+
+EXAMPLES:
+  enlang run app.enlg
+  enlang check app.enlg
+  enlang debug app.enlg
+  enlang build index.enlgf
+  enlang server --port 8080
+""")
+
+if __name__ == "__main__":
+    main()