zexus 1.6.2

package/src/zexus/lsp/completion_provider.py

@@ -0,0 +1,207 @@
+"""Completion provider for Zexus LSP."""
+
+from typing import List, Dict, Any
+try:
+    from pygls.lsp.types import CompletionItem, CompletionItemKind, Position
+    PYGLS_AVAILABLE = True
+except ImportError:
+    PYGLS_AVAILABLE = False
+
+
+# Zexus keywords
+KEYWORDS = [
+    'let', 'const', 'action', 'function', 'lambda', 'return', 'if', 'elif', 'else',
+    'while', 'for', 'each', 'in', 'match', 'case', 'default', 'break', 'continue',
+    'entity', 'data', 'enum', 'protocol', 'interface', 'type_alias', 'implements',
+    'use', 'import', 'export', 'module', 'package', 'from', 'external',
+    'protect', 'verify', 'restrict', 'require', 'assert', 'seal', 'sandbox',
+    'audit', 'trail', 'capability', 'grant', 'revoke', 'validate', 'sanitize',
+    'contract', 'state', 'ledger', 'persistent', 'storage', 'tx', 'gas', 'limit',
+    'hash', 'signature', 'verify_sig', 'emit', 'event', 'revert', 'this',
+    'public', 'private', 'pure', 'view', 'payable', 'modifier', 'sealed', 'secure',
+    'async', 'await', 'channel', 'send', 'receive', 'atomic', 'stream', 'watch',
+    'try', 'catch', 'throw', 'finally', 'defer',
+    'native', 'inline', 'gc', 'buffer', 'simd', 'pattern', 'exactly', 'embedded', 'using',
+    'screen', 'component', 'theme', 'canvas', 'graphics', 'animation', 'clock', 'color',
+    'middleware', 'auth', 'throttle', 'cache', 'inject',
+    'true', 'false', 'null', 'map', 'TX', 'print', 'debug', 'log', 'immutable'
+]
+
+# Built-in functions with their signatures
+BUILTINS = {
+    # I/O
+    'print': 'print(value)',
+    'println': 'println(value)',
+    'input': 'input(prompt)',
+    'read_text': 'read_text(path)',
+    'write_text': 'write_text(path, content)',
+    
+    # Type conversion
+    'string': 'string(value)',
+    'int': 'int(value)',
+    'float': 'float(value)',
+    'bool': 'bool(value)',
+    
+    # Collections
+    'len': 'len(collection)',
+    'list': 'list(items...)',
+    'map': 'map(pairs...)',  # Map data structure
+    'set': 'set(items...)',
+    'range': 'range(start, end, step)',
+    
+    # Functional
+    'filter': 'filter(collection, predicate)',
+    'map_transform': 'map(collection, transform)',  # Functional map
+    'reduce': 'reduce(collection, fn, initial)',
+    'sort': 'sort(collection, comparator)',
+    'reverse': 'reverse(collection)',
+    
+    # String operations
+    'join': 'join(array, separator)',
+    'split': 'split(string, delimiter)',
+    'replace': 'replace(string, old, new)',
+    'uppercase': 'uppercase(string)',
+    'lowercase': 'lowercase(string)',
+    'trim': 'trim(string)',
+    'substring': 'substring(string, start, end)',
+    
+    # Math
+    'abs': 'abs(number)',
+    'ceil': 'ceil(number)',
+    'floor': 'floor(number)',
+    'round': 'round(number, decimals)',
+    'min': 'min(numbers...)',
+    'max': 'max(numbers...)',
+    'sum': 'sum(numbers)',
+    'sqrt': 'sqrt(number)',
+    'pow': 'pow(base, exponent)',
+    'random': 'random() or random(max) or random(min, max)',
+    
+    # Date/Time
+    'now': 'now()',
+    'timestamp': 'timestamp()',
+    
+    # File I/O
+    'file_read_text': 'file_read_text(path)',
+    'file_write_text': 'file_write_text(path, content)',
+    'file_exists': 'file_exists(path)',
+    'file_read_json': 'file_read_json(path)',
+    'file_write_json': 'file_write_json(path, data)',
+    'file_append': 'file_append(path, content)',
+    'file_list_dir': 'file_list_dir(path)',
+    'read_file': 'read_file(path)',
+    'eval_file': 'eval_file(path, language)',
+    
+    # Persistence
+    'persist_set': 'persist_set(key, value)',
+    'persist_get': 'persist_get(key)',
+    'persist_clear': 'persist_clear(key)',
+    'persist_list': 'persist_list()',
+    
+    # Memory
+    'track_memory': 'track_memory()',
+    'memory_stats': 'memory_stats()',
+    
+    # Security
+    'protect': 'protect(function, policy, mode)',
+    'verify': 'verify(condition)',
+    'restrict': 'restrict(value, constraints)',
+    'create_policy': 'create_policy(rules)',
+    'enforce_policy': 'enforce_policy(policy, value)',
+    
+    # Dependency Injection
+    'register_dependency': 'register_dependency(name, impl)',
+    'inject_dependency': 'inject_dependency(name)',
+    'mock_dependency': 'mock_dependency(name, mock)',
+    'test_mode': 'test_mode(enabled)',
+    
+    # Channels
+    'send': 'send(channel, value)',
+    'receive': 'receive(channel)',
+    'close_channel': 'close_channel(channel)',
+    
+    # Blockchain
+    'emit': 'emit(event, ...args)',
+    'require': 'require(condition, message)',
+    'assert': 'assert(condition)',
+    'balance_of': 'balance_of(address)',
+    'transfer': 'transfer(to, amount)',
+    'hash': 'hash(data)',
+    'keccak256': 'keccak256(data)',
+    'signature': 'signature(data, key)',
+    'verify_sig': 'verify_sig(data, sig, key)',
+    
+    # Renderer
+    'define_screen': 'define_screen(name, props)',
+    'define_component': 'define_component(name, props)',
+    'render_screen': 'render_screen(name)',
+    'set_theme': 'set_theme(theme)',
+    
+    # Debug
+    'debug': 'debug(value)',
+    'debug_log': 'debug_log(message, context)',
+    'debug_trace': 'debug_trace()',
+    'is_main': 'is_main()',
+    'exit_program': 'exit_program(code)',
+    'module_info': 'module_info()',
+    
+    # Main entry point
+    'run': 'run(task_fn)',
+    'execute': 'execute(fn)',
+    'on_start': 'on_start(fn)',
+    'on_exit': 'on_exit(fn)',
+    'signal_handler': 'signal_handler(signal, fn)',
+    'schedule': 'schedule(fn, delay)',
+    'sleep': 'sleep(seconds)',
+    
+    # Validation
+    'is_email': 'is_email(string)',
+    'is_url': 'is_url(string)',
+    'is_phone': 'is_phone(string)',
+    'is_numeric': 'is_numeric(string)',
+    'is_alpha': 'is_alpha(string)',
+    'is_alphanumeric': 'is_alphanumeric(string)',
+    'matches_pattern': 'matches_pattern(str, pattern)',
+    'password_strength': 'password_strength(password)',
+    'sanitize_input': 'sanitize_input(text, type)',
+    'validate_length': 'validate_length(str, min, max)',
+    'env_get': 'env_get(name)',
+    'env_set': 'env_set(name, value)',
+    'env_exists': 'env_exists(name)',
+}
+
+
+class CompletionProvider:
+    """Provides completion suggestions for Zexus code."""
+
+    def get_completions(self, text: str, position: Position, doc_info: Dict[str, Any]) -> List:
+        """Get completion items for the given position."""
+        if not PYGLS_AVAILABLE:
+            return []
+        
+        items = []
+        
+        # Add keywords
+        for keyword in KEYWORDS:
+            items.append(CompletionItem(
+                label=keyword,
+                kind=CompletionItemKind.Keyword,
+                detail='Keyword',
+                documentation=f'Zexus keyword: {keyword}'
+            ))
+        
+        # Add built-in functions
+        for name, signature in BUILTINS.items():
+            items.append(CompletionItem(
+                label=name,
+                kind=CompletionItemKind.Function,
+                detail=signature,
+                documentation=f'Built-in function: {signature}',
+                insert_text=f'{name}($1)',
+                insert_text_format=2  # Snippet format
+            ))
+        
+        # TODO: Add user-defined symbols from AST
+        # TODO: Add context-aware completions
+        
+        return items

package/src/zexus/lsp/definition_provider.py

@@ -0,0 +1,22 @@
+"""Definition provider for Zexus LSP."""
+
+from typing import List, Dict, Any, Optional
+try:
+    from pygls.lsp.types import Position
+    PYGLS_AVAILABLE = True
+except ImportError:
+    PYGLS_AVAILABLE = False
+
+
+class DefinitionProvider:
+    """Provides go-to-definition for Zexus code."""
+
+    def get_definition(self, uri: str, position: Position, doc_info: Dict[str, Any]) -> Optional[List]:
+        """Get definition location for symbol at position."""
+        if not PYGLS_AVAILABLE:
+            return None
+        
+        # TODO: Implement go-to-definition by analyzing AST
+        # For now, return None
+        
+        return None

package/src/zexus/lsp/hover_provider.py

@@ -0,0 +1,71 @@
+"""Hover provider for Zexus LSP."""
+
+from typing import Dict, Any, Optional
+try:
+    from pygls.lsp.types import Hover, MarkupContent, MarkupKind, Position, Range
+    PYGLS_AVAILABLE = True
+except ImportError:
+    PYGLS_AVAILABLE = False
+
+
+class HoverProvider:
+    """Provides hover information for Zexus code."""
+
+    def get_hover(self, position: Position, doc_info: Dict[str, Any]) -> Optional[Hover]:
+        """Get hover information for the given position."""
+        if not PYGLS_AVAILABLE:
+            return None
+        
+        text = doc_info.get('text', '')
+        
+        # Get word at position
+        lines = text.split('\n')
+        if position.line >= len(lines):
+            return None
+        
+        line = lines[position.line]
+        if position.character >= len(line):
+            return None
+        
+        # Find word boundaries
+        start = position.character
+        end = position.character
+        
+        while start > 0 and (line[start - 1].isalnum() or line[start - 1] == '_'):
+            start -= 1
+        
+        while end < len(line) and (line[end].isalnum() or line[end] == '_'):
+            end += 1
+        
+        word = line[start:end]
+        
+        if not word:
+            return None
+        
+        # Provide documentation for keywords and built-ins
+        docs = {
+            'let': 'Declare a mutable variable',
+            'const': 'Declare an immutable constant',
+            'action': 'Define a function/action',
+            'contract': 'Define a smart contract',
+            'entity': 'Define a data structure',
+            'verify': 'Runtime verification with custom logic',
+            'protect': 'Apply security policy to function',
+            'print': 'Print value to console',
+            'len': 'Get length of collection',
+            # Add more...
+        }
+        
+        if word in docs:
+            return Hover(
+                contents=MarkupContent(
+                    kind=MarkupKind.Markdown,
+                    value=f'**{word}**\n\n{docs[word]}'
+                ),
+                range=Range(
+                    start=Position(line=position.line, character=start),
+                    end=Position(line=position.line, character=end)
+                )
+            )
+        
+        return None

package/src/zexus/lsp/server.py

@@ -0,0 +1,269 @@
+#!/usr/bin/env python3
+"""
+Zexus Language Server
+Implements LSP for Zexus language providing IntelliSense and other features.
+"""
+
+import logging
+import sys
+from typing import List, Optional
+
+# Configure logging first before any imports that might fail
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    stream=sys.stderr
+)
+
+logger = logging.getLogger(__name__)
+
+try:
+    from pygls.server import LanguageServer
+    from pygls.lsp.methods import (
+        TEXT_DOCUMENT_DID_OPEN,
+        TEXT_DOCUMENT_DID_CHANGE,
+        TEXT_DOCUMENT_DID_SAVE,
+        TEXT_DOCUMENT_COMPLETION,
+        TEXT_DOCUMENT_HOVER,
+        TEXT_DOCUMENT_DEFINITION,
+        TEXT_DOCUMENT_REFERENCES,
+        TEXT_DOCUMENT_DOCUMENT_SYMBOL,
+        TEXT_DOCUMENT_FORMATTING,
+        TEXT_DOCUMENT_SIGNATURE_HELP,
+    )
+    from pygls.lsp.types import (
+        CompletionItem,
+        CompletionItemKind,
+        CompletionList,
+        CompletionParams,
+        DidOpenTextDocumentParams,
+        DidChangeTextDocumentParams,
+        DidSaveTextDocumentParams,
+        Hover,
+        HoverParams,
+        Location,
+        MarkupContent,
+        MarkupKind,
+        Position,
+        Range,
+        TextDocumentPositionParams,
+        DocumentSymbol,
+        DocumentSymbolParams,
+        SymbolKind,
+        DocumentFormattingParams,
+        TextEdit,
+        SignatureHelp,
+        SignatureInformation,
+        ParameterInformation,
+        SignatureHelpParams,
+    )
+    PYGLS_AVAILABLE = True
+except ImportError:
+    PYGLS_AVAILABLE = False
+    logger.error("pygls not installed. Install with: pip install pygls")
+
+# Import Zexus modules - these should always be available if zexus is installed
+try:
+    from zexus.lexer import Lexer
+    from zexus.parser import Parser
+    from zexus.evaluator.core import Evaluator
+    from .completion_provider import CompletionProvider
+    from .symbol_provider import SymbolProvider
+    from .hover_provider import HoverProvider
+    from .definition_provider import DefinitionProvider
+    ZEXUS_AVAILABLE = True
+except ImportError as e:
+    ZEXUS_AVAILABLE = False
+    logger.error(f"Zexus modules not available: {e}")
+    logger.error("Make sure Zexus is properly installed: pip install -e .")
+
+
+if PYGLS_AVAILABLE:
+    if not ZEXUS_AVAILABLE:
+        logger.error("Error: Zexus modules not available. LSP server cannot start.")
+        raise RuntimeError("Zexus modules not available. LSP server cannot start.")
+    
+    class ZexusLanguageServer(LanguageServer):
+        """Zexus Language Server implementation."""
+
+        def __init__(self):
+            super().__init__('zexus-language-server', 'v1.6.2')
+            self.completion_provider = CompletionProvider()
+            self.symbol_provider = SymbolProvider()
+            self.hover_provider = HoverProvider()
+            self.definition_provider = DefinitionProvider()
+            self.documents = {}  # Store parsed documents
+
+
+    server = ZexusLanguageServer()
+
+
+    @server.feature(TEXT_DOCUMENT_DID_OPEN)
+    async def did_open(ls: ZexusLanguageServer, params: DidOpenTextDocumentParams):
+        """Handle document open event."""
+        logger.info(f"Document opened: {params.text_document.uri}")
+        uri = params.text_document.uri
+        text = params.text_document.text
+        
+        # Parse the document
+        try:
+            lexer = Lexer(text)
+            tokens = lexer.tokenize()
+            parser = Parser(tokens)
+            ast = parser.parse()
+            ls.documents[uri] = {
+                'text': text,
+                'ast': ast,
+                'tokens': tokens
+            }
+            logger.info(f"Document parsed successfully: {uri}")
+        except Exception as e:
+            logger.error(f"Error parsing document {uri}: {e}")
+            ls.documents[uri] = {
+                'text': text,
+                'ast': None,
+                'tokens': []
+            }
+
+
+    @server.feature(TEXT_DOCUMENT_DID_CHANGE)
+    async def did_change(ls: ZexusLanguageServer, params: DidChangeTextDocumentParams):
+        """Handle document change event."""
+        uri = params.text_document.uri
+        changes = params.content_changes
+        
+        if changes:
+            text = changes[0].text
+            # Re-parse the document
+            try:
+                lexer = Lexer(text)
+                tokens = lexer.tokenize()
+                parser = Parser(tokens)
+                ast = parser.parse()
+                ls.documents[uri] = {
+                    'text': text,
+                    'ast': ast,
+                    'tokens': tokens
+                }
+            except Exception as e:
+                logger.error(f"Error parsing document {uri}: {e}")
+                ls.documents[uri] = {
+                    'text': text,
+                    'ast': None,
+                    'tokens': []
+                }
+
+
+    @server.feature(TEXT_DOCUMENT_DID_SAVE)
+    async def did_save(ls: ZexusLanguageServer, params: DidSaveTextDocumentParams):
+        """Handle document save event."""
+        logger.info(f"Document saved: {params.text_document.uri}")
+
+
+    @server.feature(TEXT_DOCUMENT_COMPLETION)
+    async def completions(ls: ZexusLanguageServer, params: CompletionParams) -> CompletionList:
+        """Provide completion items."""
+        uri = params.text_document.uri
+        position = params.position
+        
+        doc_info = ls.documents.get(uri, {})
+        text = doc_info.get('text', '')
+        
+        items = ls.completion_provider.get_completions(text, position, doc_info)
+        return CompletionList(is_incomplete=False, items=items)
+
+
+    @server.feature(TEXT_DOCUMENT_HOVER)
+    async def hover(ls: ZexusLanguageServer, params: HoverParams) -> Optional[Hover]:
+        """Provide hover information."""
+        uri = params.text_document.uri
+        position = params.position
+        
+        doc_info = ls.documents.get(uri, {})
+        
+        return ls.hover_provider.get_hover(position, doc_info)
+
+
+    @server.feature(TEXT_DOCUMENT_DEFINITION)
+    async def definition(ls: ZexusLanguageServer, params: TextDocumentPositionParams) -> Optional[List[Location]]:
+        """Provide go-to-definition."""
+        uri = params.text_document.uri
+        position = params.position
+        
+        doc_info = ls.documents.get(uri, {})
+        
+        return ls.definition_provider.get_definition(uri, position, doc_info)
+
+
+    @server.feature(TEXT_DOCUMENT_DOCUMENT_SYMBOL)
+    async def document_symbols(ls: ZexusLanguageServer, params: DocumentSymbolParams) -> List[DocumentSymbol]:
+        """Provide document symbols for outline view."""
+        uri = params.text_document.uri
+        doc_info = ls.documents.get(uri, {})
+        
+        return ls.symbol_provider.get_symbols(doc_info)
+
+
+    @server.feature(TEXT_DOCUMENT_FORMATTING)
+    async def formatting(ls: ZexusLanguageServer, params: DocumentFormattingParams) -> List[TextEdit]:
+        """Format document."""
+        # TODO: Implement code formatting
+        return []
+
+
+    @server.feature(TEXT_DOCUMENT_SIGNATURE_HELP)
+    async def signature_help(ls: ZexusLanguageServer, params: SignatureHelpParams) -> Optional[SignatureHelp]:
+        """Provide signature help for function calls."""
+        uri = params.text_document.uri
+        position = params.position
+        
+        doc_info = ls.documents.get(uri, {})
+        text = doc_info.get('text', '')
+        
+        # Get current line
+        lines = text.split('\n')
+        if position.line >= len(lines):
+            return None
+        
+        current_line = lines[position.line][:position.character]
+        
+        # Simple signature help for built-in functions
+        # TODO: Make this more sophisticated by parsing AST
+        builtins_signatures = {
+            'print': SignatureInformation(
+                label='print(value)',
+                documentation='Print value to console',
+                parameters=[ParameterInformation(label='value', documentation='Value to print')]
+            ),
+            'len': SignatureInformation(
+                label='len(collection)',
+                documentation='Get length of collection',
+                parameters=[ParameterInformation(label='collection', documentation='Collection to measure')]
+            ),
+            # Add more built-ins...
+        }
+        
+        # Find which function is being called
+        for func_name, sig in builtins_signatures.items():
+            if func_name + '(' in current_line:
+                return SignatureHelp(
+                    signatures=[sig],
+                    active_signature=0,
+                    active_parameter=0
+                )
+        
+        return None
+
+
+    def main():
+        """Start the language server."""
+        logger.info("Starting Zexus Language Server...")
+        server.start_io()
+
+
+    if __name__ == '__main__':
+        main()
+else:
+    def main():
+        print("Error: pygls is not installed. Please install it with: pip install pygls", file=sys.stderr)
+        sys.exit(1)

package/src/zexus/lsp/symbol_provider.py

@@ -0,0 +1,31 @@
+"""Symbol provider for Zexus LSP."""
+
+from typing import List, Dict, Any
+try:
+    from pygls.lsp.types import (DocumentSymbol, SymbolKind, Range, Position)
+    PYGLS_AVAILABLE = True
+except ImportError:
+    PYGLS_AVAILABLE = False
+    # Define minimal stubs when pygls not available
+    class SymbolKind:
+        pass
+
+
+class SymbolProvider:
+    """Provides document symbols for outline view."""
+
+    def get_symbols(self, doc_info: Dict[str, Any]) -> List:
+        """Get document symbols from AST."""
+        if not PYGLS_AVAILABLE:
+            return []
+        
+        symbols = []
+        ast = doc_info.get('ast')
+        
+        if not ast:
+            return symbols
+        
+        # TODO: Walk AST and extract symbols
+        # For now, return empty list
+        
+        return symbols