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

shell_lite/js_compiler.py

@@ -1,220 +0,0 @@
-import random
-from typing import List
-from .ast_nodes import *
-class JSCompiler:
-    def __init__(self):
-        self.indentation = 0
-    def indent(self):
-        return "    " * self.indentation
-    def visit(self, node: Node) -> str:
-        method_name = f'visit_{type(node).__name__}'
-        visitor = getattr(self, method_name, self.generic_visit)
-        return visitor(node)
-    def generic_visit(self, node: Node):
-        raise Exception(f"JSCompiler does not support {type(node).__name__}")
-    def compile_block(self, statements: List[Node]) -> str:
-        if not statements:
-            return ""
-        code = ""
-        for stmt in statements:
-            stmt_code = self.visit(stmt)
-            if not stmt_code: continue
-            indented_stmt = "\n".join([f"{self.indent()}{line}" for line in stmt_code.split('\n')])
-            code += indented_stmt + "\n"
-        return code.rstrip()
-    def compile(self, statements: List[Node]) -> str:
-        code = [
-            "// ShellLite Runtime (JS)",
-            "const fs = require('fs');",
-            "const path = require('path');",
-            "const https = require('https');",
-            "const { execSync } = require('child_process');",
-            "",
-            "// Builtins",
-            "const say = console.log;",
-            "const print = console.log;",
-            "const range = (n) => [...Array(n).keys()];",
-            "const int = (x) => parseInt(x);",
-            "const str = (x) => String(x);",
-            "const float = (x) => parseFloat(x);",
-            "const len = (x) => x.length;",
-            "",
-            "// Utils",
-            "const _slang_download = (url) => { console.log('Download not impl in minimal JS runtime'); };",
-            "",
-            "// --- User Code ---",
-            ""
-        ]
-        code.append(self.compile_block(statements))
-        return "\n".join(code)
-    def visit_Number(self, node: Number):
-        return str(node.value)
-    def visit_String(self, node: String):
-        return repr(node.value) 
-    def visit_Boolean(self, node: Boolean):
-        return "true" if node.value else "false"
-    def visit_Regex(self, node: Regex):
-        return f"/{node.pattern}/"
-    def visit_ListVal(self, node: ListVal):
-        elements = [self.visit(e) for e in node.elements]
-        return f"[{', '.join(elements)}]"
-    def visit_Dictionary(self, node: Dictionary):
-        pairs = [f"{self.visit(k)}: {self.visit(v)}" for k, v in node.pairs]
-        return f"{{{', '.join(pairs)}}}"
-    def visit_SetVal(self, node: SetVal):
-        elements = [self.visit(e) for e in node.elements]
-        return f"new Set([{', '.join(elements)}])"
-    def visit_VarAccess(self, node: VarAccess):
-        return node.name
-    def visit_Assign(self, node: Assign):
-        return f"var {node.name} = {self.visit(node.value)};"
-    def visit_ConstAssign(self, node: ConstAssign):
-        return f"const {node.name} = {self.visit(node.value)};"
-    def visit_PropertyAssign(self, node: PropertyAssign):
-        return f"{node.instance_name}.{node.property_name} = {self.visit(node.value)};"
-    def visit_BinOp(self, node: BinOp):
-        left = self.visit(node.left)
-        right = self.visit(node.right)
-        op = node.op
-        js_ops = {
-            'matches': None, 
-            'and': '&&',
-            'or': '||',
-            '==': '==='
-        }
-        if op == 'matches':
-            return f"new RegExp({right}).test({left})"
-        real_op = js_ops.get(op, op)
-        return f"({left} {real_op} {right})"
-    def visit_UnaryOp(self, node: UnaryOp):
-        return f"({node.op} {self.visit(node.right)})"
-    def visit_Print(self, node: Print):
-        return f"console.log({self.visit(node.expression)});"
-    def visit_Input(self, node: Input):
-        return f"require('readline-sync').question({repr(node.prompt) if node.prompt else '\"\"'})"
-    def visit_If(self, node: If):
-        code = f"if ({self.visit(node.condition)}) {{\n"
-        self.indentation += 1
-        code += self.compile_block(node.body)
-        self.indentation -= 1
-        code += f"\n{self.indent()}}}"
-        if node.else_body:
-            code += f" else {{\n"
-            self.indentation += 1
-            code += self.compile_block(node.else_body)
-            self.indentation -= 1
-            code += f"\n{self.indent()}}}"
-        return code
-    def visit_While(self, node: While):
-        code = f"while ({self.visit(node.condition)}) {{\n"
-        self.indentation += 1
-        code += self.compile_block(node.body)
-        self.indentation -= 1
-        code += f"\n{self.indent()}}}"
-        return code
-    def visit_For(self, node: For):
-        count = self.visit(node.count)
-        var = f"_i_{random.randint(0,1000)}"
-        code = f"for (let {var} = 0; {var} < {count}; {var}++) {{\n"
-        self.indentation += 1
-        code += self.compile_block(node.body)
-        self.indentation -= 1
-        code += f"\n{self.indent()}}}"
-        return code
-    def visit_ForIn(self, node: ForIn):
-        code = f"for (let {node.var_name} of {self.visit(node.iterable)}) {{\n"
-        self.indentation += 1
-        code += self.compile_block(node.body)
-        self.indentation -= 1
-        code += f"\n{self.indent()}}}"
-        return code
-    def visit_Repeat(self, node: Repeat):
-        return self.visit_For(For(node.count, node.body))
-    def visit_FunctionDef(self, node: FunctionDef):
-        args = [arg[0] for arg in node.args] 
-        code = f"function {node.name}({', '.join(args)}) {{\n"
-        self.indentation += 1
-        code += self.compile_block(node.body)
-        self.indentation -= 1
-        code += f"\n{self.indent()}}}"
-        return code
-    def visit_Return(self, node: Return):
-        return f"return {self.visit(node.value)};"
-    def visit_Call(self, node: Call):
-        args = [self.visit(a) for a in node.args]
-        return f"{node.name}({', '.join(args)})"
-    def visit_ClassDef(self, node: ClassDef):
-        parent = node.parent if node.parent else ""
-        extends = f" extends {parent}" if parent else ""
-        code = f"class {node.name}{extends} {{\n"
-        self.indentation += 1
-        if 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 assign in assigns:
-                 code += f"{self.indent()}{assign}\n"
-            self.indentation -= 1
-            code += f"{self.indent()}}}\n"
-        for m in node.methods:
-             args = [arg[0] for arg in m.args]
-             code += f"\n{self.indent()}{m.name}({', '.join(args)}) {{\n"
-             self.indentation += 1
-             code += self.compile_block(m.body)
-             self.indentation -= 1
-             code += f"\n{self.indent()}}}"
-        self.indentation -= 1
-        code += f"\n{self.indent()}}}"
-        return code
-    def visit_Instantiation(self, node: Instantiation):
-        args = [self.visit(a) for a in node.args]
-        return f"var {node.var_name} = new {node.class_name}({', '.join(args)});"
-    def visit_MethodCall(self, node: MethodCall):
-        args = [self.visit(a) for a in node.args]
-        return f"{node.instance_name}.{node.method_name}({', '.join(args)})"
-    def visit_PropertyAccess(self, node: PropertyAccess):
-        return f"{node.instance_name}.{node.property_name}"
-    def visit_Import(self, node: Import):
-        base = node.path
-        if base == 'vscode': return 'const vscode = require("vscode");'
-        return f"const {base} = require('./{base}');"
-    def visit_ImportAs(self, node: ImportAs):
-        path = node.path
-        if path == 'vscode': return f"const {node.alias} = require('vscode');"
-        return f"const {node.alias} = require('./{path}');"
-    def visit_Try(self, node: Try):
-        code = f"try {{\n"
-        self.indentation += 1
-        code += self.compile_block(node.try_body)
-        self.indentation -= 1
-        code += f"\n{self.indent()}}} catch ({node.catch_var}) {{\n"
-        self.indentation += 1
-        code += self.compile_block(node.catch_body)
-        self.indentation -= 1
-        code += f"\n{self.indent()}}}"
-        return code
-    def visit_Throw(self, node: Throw):
-        return f"throw new Error({self.visit(node.message)});"
-    def visit_Skip(self, node: Skip):
-        return "continue;"
-    def visit_Stop(self, node: Stop):
-        return "break;"
-    def visit_Lambda(self, node: Lambda):
-        return f"({', '.join(node.params)}) => {self.visit(node.body)}"
-    def visit_Execute(self, node: Execute):
-         pass

shell_lite/lexer_new.py

@@ -1,252 +0,0 @@
-import re
-from dataclasses import dataclass
-from typing import List, Optional
-@dataclass
-@dataclass
-class Token:
-    type: str
-    value: str
-    line: int
-    column: int = 1
-class Lexer:
-    def __init__(self, source_code: str):
-        self.source_code = source_code
-        self.tokens: List[Token] = []
-        self.current_char_index = 0
-        self.line_number = 1
-        self.indent_stack = [0]
-    def tokenize(self) -> List[Token]:
-        source = self._remove_multiline_comments(self.source_code)
-        lines = source.split('\n')
-        for line_num, line in enumerate(lines, 1):
-            self.line_number = line_num
-            stripped_line = line.strip()
-            if not stripped_line:
-                continue
-            indent_level = len(line) - len(line.lstrip())
-            if stripped_line.startswith('#'):
-                # self.tokens.append(Token('COMMENT', stripped_line, self.line_number, indent_level + 1))
-                # self.tokens.append(Token('NEWLINE', '', self.line_number, len(line) + 1))
-                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))
-            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}")
-            self.tokenize_line(stripped_line, indent_level + 1)
-            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))
-        return self.tokens
-    def _remove_multiline_comments(self, source: str) -> str:
-        result = []
-        i = 0
-        while i < len(source):
-            if source[i:i+2] == '/*':
-                end = source.find('*/', i + 2)
-                if end == -1:
-                    raise SyntaxError("Unterminated multi-line comment")
-                comment = source[i:end+2]
-                result.append('\n' * comment.count('\n'))
-                i = end + 2
-            else:
-                result.append(source[i])
-                i += 1
-        return ''.join(result)
-    def tokenize_line(self, line: str, start_col: int = 1):
-        pos = 0
-        while pos < len(line):
-            match = None
-            current_col = start_col + pos
-            if line[pos] == '#':
-                self.tokens.append(Token('COMMENT', line[pos:], self.line_number, current_col))
-                break
-            if line[pos].isspace():
-                pos += 1
-                continue
-            if line[pos].isdigit():
-                match = re.match(r'^\d+(\.\d+)?', line[pos:])
-                if match:
-                    value = match.group(0)
-                    self.tokens.append(Token('NUMBER', value, self.line_number, current_col))
-                    pos += len(value)
-                    continue
-            if line[pos:pos+3] in ('"""', "'''"):
-                 quote_char = line[pos:pos+3]
-                 pass
-            if line[pos] in ('"', "'"):
-                quote_char = line[pos]
-                end_quote = line.find(quote_char, pos + 1)
-                if end_quote == -1:
-                    raise SyntaxError(f"Unterminated string on line {self.line_number}")
-                value = line[pos+1:end_quote]
-                value = value.replace("\\n", "\n").replace("\\t", "\t").replace("\\r", "\r").replace("\\\"", "\"").replace("\\\'", "\'")
-                self.tokens.append(Token('STRING', value, self.line_number, current_col))
-                pos = end_quote + 1
-                continue
-            if line[pos:pos+3] == '...':
-                self.tokens.append(Token('DOTDOTDOT', '...', self.line_number, current_col))
-                pos += 3
-                continue
-            two_char = line[pos:pos+2]
-            two_char_tokens = {
-                '=>': 'ARROW', '==': 'EQ', '!=': 'NEQ',
-                '<=': 'LE', '>=': 'GE', '+=': 'PLUSEQ',
-                '-=': 'MINUSEQ', '*=': 'MULEQ', '/=': 'DIVEQ',
-                '%=': 'MODEQ'
-            }
-            if two_char in two_char_tokens:
-                self.tokens.append(Token(two_char_tokens[two_char], two_char, self.line_number, current_col))
-                pos += 2
-                continue
-            char = line[pos]
-            rest_of_line = line[pos:]
-            if rest_of_line.startswith('is at least '):
-                self.tokens.append(Token('GE', '>=', self.line_number, current_col))
-                pos += 12 
-                continue
-            elif rest_of_line.startswith('is exactly '):
-                self.tokens.append(Token('EQ', '==', self.line_number, current_col))
-                pos += 11
-                continue
-            elif rest_of_line.startswith('is less than '):
-                self.tokens.append(Token('LT', '<', self.line_number, current_col))
-                pos += 13
-                continue
-            elif rest_of_line.startswith('is more than '):
-                self.tokens.append(Token('GT', '>', self.line_number, current_col))
-                pos += 13
-                continue
-            if rest_of_line.startswith('the') and (len(rest_of_line) == 3 or not rest_of_line[3].isalnum()):
-                 pos += 3
-                 continue
-            if char == '/':
-                last_type = self.tokens[-1].type if self.tokens else None
-                is_division = False
-                if last_type in ('NUMBER', 'STRING', 'ID', 'RPAREN', 'RBRACKET'):
-                     is_division = True
-                if not is_division:
-                    end_slash = line.find('/', pos + 1)
-                    if end_slash != -1:
-                        pattern = line[pos+1:end_slash]
-                        flags = ""
-                        k = end_slash + 1
-                        while k < len(line) and line[k].isalpha():
-                            flags += line[k]
-                            k += 1
-                        self.tokens.append(Token('REGEX', pattern, self.line_number, current_col))
-                        pos = k
-                        continue
-            single_char_tokens = {
-                '+': 'PLUS', '-': 'MINUS', '*': 'MUL', '/': 'DIV',
-                '%': 'MOD', '=': 'ASSIGN', '>': 'GT', '<': 'LT',
-                '?': 'QUESTION', '(': 'LPAREN', ')': 'RPAREN',
-                '[': 'LBRACKET', ']': 'RBRACKET', ':': 'COLON',
-                '{': 'LBRACE', '}': 'RBRACE', ',': 'COMMA', '.': 'DOT'
-            }
-            if char in single_char_tokens:
-                self.tokens.append(Token(single_char_tokens[char], char, self.line_number, current_col))
-                pos += 1
-                continue
-            if char.isalpha() or char == '_':
-                match = re.match(r'^[a-zA-Z_][a-zA-Z0-9_]*', line[pos:])
-                if match:
-                    value = match.group(0)
-                    keywords = {
-                        'if': 'IF', 'else': 'ELSE', 'elif': 'ELIF',
-                        'for': 'FOR', 'in': 'IN', 'range': 'RANGE',
-                        'loop': 'LOOP', 'times': 'TIMES',
-                        'while': 'WHILE', 'until': 'UNTIL',
-                        'repeat': 'REPEAT', 'forever': 'FOREVER',
-                        'stop': 'STOP', 'skip': 'SKIP', 'exit': 'EXIT',
-                        'each': 'FOR',
-                        'unless': 'UNLESS', 'when': 'WHEN', 'otherwise': 'OTHERWISE',
-                        'then': 'THEN', 'do': 'DO',
-                        'print': 'PRINT', 'say': 'SAY', 'show': 'SAY',
-                        'input': 'INPUT', 'ask': 'ASK',
-                        'to': 'TO', 'can': 'TO',
-                        'return': 'RETURN', 'give': 'RETURN',
-                        'fn': 'FN',
-                        'structure': 'STRUCTURE', 'thing': 'STRUCTURE', 'class': 'STRUCTURE',
-                        'has': 'HAS', 'with': 'WITH',
-                        'is': 'IS', 'extends': 'EXTENDS', 'from': 'FROM',
-                        'make': 'MAKE', 'new': 'MAKE',
-                        'yes': 'YES', 'no': 'NO',
-                        'true': 'YES', 'false': 'NO',
-                        'const': 'CONST',
-                        'and': 'AND', 'or': 'OR', 'not': 'NOT',
-                        'try': 'TRY', 'catch': 'CATCH', 'always': 'ALWAYS',
-                        'use': 'USE', 'as': 'AS', 'share': 'SHARE',
-                        'execute': 'EXECUTE', 'run': 'EXECUTE',
-                        'alert': 'ALERT', 'prompt': 'PROMPT', 'confirm': 'CONFIRM',
-                        'spawn': 'SPAWN', 'await': 'AWAIT',
-                        'matches': 'MATCHES',
-                        'on': 'ON',
-                        'download': 'DOWNLOAD',
-                        'compress': 'COMPRESS', 'extract': 'EXTRACT', 'folder': 'FOLDER',
-                        'load': 'LOAD', 'save': 'SAVE', 'csv': 'CSV',
-                        'copy': 'COPY', 'paste': 'PASTE', 'clipboard': 'CLIPBOARD',
-                        'press': 'PRESS', 'type': 'TYPE', 'click': 'CLICK', 'at': 'AT',
-                        'notify': 'NOTIFY',
-                        'date': 'ID', 'today': 'ID', 'after': 'AFTER', 'before': 'BEFORE',
-                        'list': 'LIST', 'set': 'SET', 'unique': 'UNIQUE', 'of': 'OF',
-                        'wait': 'WAIT',
-                        'convert': 'CONVERT', 'json': 'JSON',
-                        'listen': 'LISTEN', 'port': 'PORT',
-                        'every': 'EVERY', 'minute': 'MINUTE', 'minutes': 'MINUTE',
-                        'second': 'SECOND', 'seconds': 'SECOND',
-                        'progress': 'PROGRESS',
-                        'bold': 'BOLD',
-                        'red': 'RED', 'green': 'GREEN', 'blue': 'BLUE', 
-                        'yellow': 'YELLOW', 'cyan': 'CYAN', 'magenta': 'MAGENTA',
-                        'serve': 'SERVE', 'static': 'STATIC',
-                        'write': 'WRITE', 'append': 'APPEND', 'read': 'READ', 'file': 'FILE',
-                        'write': 'WRITE', 'append': 'APPEND', 'read': 'READ', 'file': 'FILE',
-                        'db': 'DB', 'database': 'DB',
-                        'query': 'QUERY', 'open': 'OPEN', 'close': 'CLOSE', 'exec': 'EXEC',
-                        'middleware': 'MIDDLEWARE', 'before': 'BEFORE',
-                        'when': 'WHEN', 'someone': 'SOMEONE', 'visits': 'VISITS', 
-                        'submits': 'SUBMITS', 'start': 'START', 'server': 'SERVER',
-                        'files': 'FILES',
-                        'define': 'DEFINE', 'page': 'PAGE', 'called': 'CALLED',
-                        'using': 'USING', 'component': 'PAGE',
-                        'heading': 'HEADING', 'paragraph': 'PARAGRAPH',
-                        'image': 'IMAGE',
-                        'add': 'ADD', 'put': 'ADD', 'into': 'INTO',
-                        'count': 'COUNT', 'many': 'MANY', 'how': 'HOW',
-                        'field': 'FIELD', 'submit': 'SUBMIT', 'named': 'NAMED',
-                        'placeholder': 'PLACEHOLDER',
-                        'app': 'APP', 'title': 'ID', 'size': 'SIZE',
-                        'column': 'COLUMN', 'row': 'ROW',
-                        'button': 'BUTTON', 'heading': 'HEADING', 
-                        'sum': 'SUM', 'upper': 'UPPER', 'lower': 'LOWER',
-                        'increment': 'INCREMENT', 'decrement': 'DECREMENT',
-                        'multiply': 'MULTIPLY', 'divide': 'DIVIDE',
-                        'be': 'BE', 'by': 'BY',
-                        'plus': 'PLUS', 'minus': 'MINUS', 'divided': 'DIV',
-                        'greater': 'GREATER', 'less': 'LESS', 'equal': 'EQUAL',
-                        'define': 'DEFINE', 'function': 'FUNCTION',
-                        'contains': 'CONTAINS', 'empty': 'EMPTY',
-                        'remove': 'REMOVE',
-                        'than': 'THAN',
-                        'doing': 'DOING',
-                        'make': 'MAKE', 'be': 'BE',
-                        'as': 'AS', 'long': 'LONG',
-                        'otherwise': 'OTHERWISE',
-                        'ask': 'ASK',
-                    }
-                    token_type = keywords.get(value, 'ID')
-                    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/minimal_interpreter.py

@@ -1,25 +0,0 @@
-
-class Environment:
-    def __init__(self, parent=None):
-        self.variables = {}
-        self.parent = parent
-    def get(self, name):
-        if name in self.variables: return self.variables[name]
-        if self.parent: return self.parent.get(name)
-        raise NameError(f"Var '{name}' not found")
-    def set(self, name, val):
-        self.variables[name] = val
-
-class Interpreter:
-    def __init__(self):
-        print("DEBUG: MINIMAL INTERPRETER LOADED")
-        self.global_env = Environment()
-        self.current_env = self.global_env
-        self.functions = {}
-        self.builtins = {
-            'str': str,
-            'print': print
-        }
-    def visit(self, node):
-        print(f"Visiting {type(node).__name__}")
-        return None