jarvis-ai-assistant 0.1.104__py3-none-any.whl → 0.1.106__py3-none-any.whl

jarvis/jarvis_lsp/go.py

@@ -0,0 +1,140 @@
+import os
+import shutil
+import subprocess
+from typing import List, Dict, Optional, Tuple, Any
+import json
+from jarvis.jarvis_lsp.base import BaseLSP
+from jarvis.utils import PrettyOutput, OutputType
+
+class GoLSP(BaseLSP):
+    """Go LSP implementation using gopls."""
+    
+    language = "go"
+
+    @staticmethod
+    def check() -> bool:
+        """Check if gopls is installed."""
+        return shutil.which("gopls") is not None
+    
+    def __init__(self):
+        self.workspace_path = ""
+        self.gopls_process = None
+        self.request_id = 0
+    
+    def initialize(self, workspace_path: str) -> bool:
+        try:
+            self.workspace_path = workspace_path
+            # Start gopls process
+            self.gopls_process = subprocess.Popen(
+                ["gopls", "serve"],
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE
+            )
+            
+            # Send initialize request
+            self._send_request("initialize", {
+                "processId": os.getpid(),
+                "rootUri": f"file://{workspace_path}",
+                "capabilities": {
+                    "textDocument": {
+                        "hover": {"contentFormat": ["markdown", "plaintext"]},
+                        "completion": {"completionItem": {"snippetSupport": True}},
+                        "signatureHelp": {"signatureInformation": {"documentationFormat": ["markdown", "plaintext"]}},
+                    }
+                }
+            })
+            
+            return True
+        except Exception as e:
+            PrettyOutput.print(f"Go LSP initialization failed: {str(e)}", OutputType.ERROR)
+            return False
+    
+    def _send_request(self, method: str, params: Dict) -> Optional[Dict]:
+        """Send JSON-RPC request to gopls."""
+        if not self.gopls_process:
+            return None
+            
+        try:
+            self.request_id += 1
+            request = {
+                "jsonrpc": "2.0",
+                "id": self.request_id,
+                "method": method,
+                "params": params
+            }
+            
+            self.gopls_process.stdin.write(json.dumps(request).encode() + b"\n") # type: ignore
+            self.gopls_process.stdin.flush() # type: ignore
+            
+            response = json.loads(self.gopls_process.stdout.readline().decode()) # type: ignore
+            return response.get("result")
+        except Exception:
+            return None
+    
+    def find_references(self, file_path: str, position: Tuple[int, int]) -> List[Dict[str, Any]]:
+        result = self._send_request("textDocument/references", {
+            "textDocument": {"uri": f"file://{file_path}"},
+            "position": {"line": position[0], "character": position[1]},
+            "context": {"includeDeclaration": True}
+        })
+        return result or [] # type: ignore
+    
+    def find_definition(self, file_path: str, position: Tuple[int, int]) -> Optional[Dict[str, Any]]:
+        result = self._send_request("textDocument/definition", {
+            "textDocument": {"uri": f"file://{file_path}"},
+            "position": {"line": position[0], "character": position[1]}
+        })
+        return result[0] if result else None
+    
+    def get_document_symbols(self, file_path: str) -> List[Dict[str, Any]]:
+        result = self._send_request("textDocument/documentSymbol", {
+            "textDocument": {"uri": f"file://{file_path}"}
+        })
+        return result or [] # type: ignore
+    
+    def get_diagnostics(self, file_path: str) -> List[Dict[str, Any]]:
+        # Send didOpen notification to trigger diagnostics
+        self._send_request("textDocument/didOpen", {
+            "textDocument": {
+                "uri": f"file://{file_path}",
+                "languageId": "go",
+                "version": 1,
+                "text": open(file_path).read()
+            }
+        })
+        
+        # Wait for diagnostic notification
+        try:
+            response = json.loads(self.gopls_process.stdout.readline().decode()) # type: ignore
+            if response.get("method") == "textDocument/publishDiagnostics":
+                return response.get("params", {}).get("diagnostics", [])
+        except Exception:
+            pass
+        return []
+    
+    def prepare_rename(self, file_path: str, position: Tuple[int, int]) -> Optional[Dict[str, Any]]:
+        result = self._send_request("textDocument/prepareRename", {
+            "textDocument": {"uri": f"file://{file_path}"},
+            "position": {"line": position[0], "character": position[1]}
+        })
+        return result
+    
+    def validate_edit(self, file_path: str, edit: Dict[str, Any]) -> bool:
+        # Send workspace/willRenameFiles request to check validity
+        result = self._send_request("workspace/willRenameFiles", {
+            "files": [{
+                "oldUri": f"file://{file_path}",
+                "newUri": f"file://{file_path}.tmp"
+            }]
+        })
+        return bool(result)
+    
+    def shutdown(self):
+        if self.gopls_process:
+            try:
+                self._send_request("shutdown", {})
+                self.gopls_process.terminate()
+                self.gopls_process = None
+            except Exception:
+                pass

jarvis/jarvis_lsp/python.py

@@ -0,0 +1,135 @@
+import os
+from typing import List, Dict, Optional, Tuple, Any
+import jedi
+from jarvis.jarvis_lsp.base import BaseLSP
+from jarvis.utils import PrettyOutput, OutputType
+
+class PythonLSP(BaseLSP):
+    """Python LSP implementation using jedi."""
+    
+    language = "python"
+    
+    def __init__(self):
+        self.workspace_path = ""
+        self.script_cache = {}
+    
+    def initialize(self, workspace_path: str) -> bool:
+        self.workspace_path = workspace_path
+        return True
+    
+    def _get_script(self, file_path: str):
+        if file_path not in self.script_cache:
+            try:
+                with open(file_path, 'r') as f:
+                    content = f.read()
+                self.script_cache[file_path] = jedi.Script(code=content, path=file_path)
+            except Exception:
+                return None
+        return self.script_cache[file_path]
+    
+    def find_references(self, file_path: str, position: Tuple[int, int]) -> List[Dict[str, Any]]:
+        script = self._get_script(file_path)
+        if not script:
+            return []
+        try:
+            refs = script.get_references(line=position[0] + 1, column=position[1])
+            return [self._location_to_dict(ref) for ref in refs]
+        except Exception:
+            return []
+    
+    def find_definition(self, file_path: str, position: Tuple[int, int]) -> Optional[Dict[str, Any]]:
+        script = self._get_script(file_path)
+        if not script:
+            return None
+        try:
+            defs = script.goto(line=position[0] + 1, column=position[1])
+            return self._location_to_dict(defs[0]) if defs else None
+        except Exception:
+            return None
+    
+    def _location_to_dict(self, location) -> Dict[str, Any]:
+        return {
+            "uri": location.module_path,
+            "range": {
+                "start": {"line": location.line - 1, "character": location.column},
+                "end": {"line": location.line - 1, "character": location.column + len(location.name)}
+            }
+        }
+    
+    def get_document_symbols(self, file_path: str) -> List[Dict[str, Any]]:
+        script = self._get_script(file_path)
+        if not script:
+            return []
+        try:
+            names = script.get_names()
+            return [self._location_to_dict(name) for name in names]
+        except Exception:
+            return []
+    
+    def get_diagnostics(self, file_path: str) -> List[Dict[str, Any]]:
+        script = self._get_script(file_path)
+        if not script:
+            return []
+        try:
+            errors = script.get_syntax_errors()
+            return [{
+                "range": {
+                    "start": {"line": e.line - 1, "character": e.column},
+                    "end": {"line": e.line - 1, "character": e.column + 1}
+                },
+                "severity": 1,  # Error
+                "source": "jedi",
+                "message": str(e)
+            } for e in errors]
+        except Exception:
+            return []
+    
+    def prepare_rename(self, file_path: str, position: Tuple[int, int]) -> Optional[Dict[str, Any]]:
+        script = self._get_script(file_path)
+        if not script:
+            return None
+        try:
+            refs = script.get_references(line=position[0] + 1, column=position[1])
+            if refs:
+                ref = refs[0]
+                return {
+                    "range": {
+                        "start": {"line": ref.line - 1, "character": ref.column},
+                        "end": {"line": ref.line - 1, "character": ref.column + len(ref.name)}
+                    }
+                }
+        except Exception:
+            return None
+        return None
+    
+    def validate_edit(self, file_path: str, edit: Dict[str, Any]) -> bool:
+        try:
+            # Simple syntax check of the edited content
+            content = ""
+            with open(file_path, 'r') as f:
+                content = f.read()
+            
+            # Apply edit
+            start = edit["range"]["start"]
+            end = edit["range"]["end"]
+            new_text = edit["newText"]
+            
+            lines = content.splitlines(True)
+            before = "".join(lines[:start["line"]])
+            after = "".join(lines[end["line"] + 1:])
+            current_line = lines[start["line"]]
+            
+            edited_line = (current_line[:start["character"]] + 
+                         new_text + 
+                         current_line[end["character"]:])
+            
+            new_content = before + edited_line + after
+            
+            # Check if new content is valid Python
+            jedi.Script(code=new_content)
+            return True
+        except Exception:
+            return False
+    
+    def shutdown(self):
+        self.script_cache.clear()

jarvis/jarvis_lsp/registry.py

@@ -0,0 +1,234 @@
+import importlib
+import inspect
+import os
+import re
+import sys
+from typing import Dict, Type, Optional, List
+from jarvis.jarvis_lsp.base import BaseLSP
+from jarvis.utils import PrettyOutput, OutputType
+
+REQUIRED_METHODS = [
+    ('initialize', ['workspace_path']),
+    ('find_references', ['file_path', 'position']),
+    ('find_definition', ['file_path', 'position']),
+    ('get_document_symbols', ['file_path']),
+    ('get_diagnostics', ['file_path']),
+    ('prepare_rename', ['file_path', 'position']),
+    ('validate_edit', ['file_path', 'edit']),
+    ('shutdown', [])
+]
+
+class LSPRegistry:
+    """LSP server registry"""
+
+    global_lsp_registry = None
+
+    @staticmethod
+    def get_lsp_dir() -> str:
+        """Get LSP implementation directory."""
+        user_lsp_dir = os.path.expanduser("~/.jarvis/lsp")
+        if not os.path.exists(user_lsp_dir):
+            try:
+                os.makedirs(user_lsp_dir)
+                with open(os.path.join(user_lsp_dir, "__init__.py"), "w") as f:
+                    pass
+            except Exception as e:
+                PrettyOutput.print(f"Create LSP directory failed: {str(e)}", OutputType.ERROR)
+                return ""
+        return user_lsp_dir
+
+    @staticmethod
+    def check_lsp_implementation(lsp_class: Type[BaseLSP]) -> bool:
+        """Check if the LSP class implements all necessary methods."""
+        missing_methods = []
+        
+        for method_name, params in REQUIRED_METHODS:
+            if not hasattr(lsp_class, method_name):
+                missing_methods.append(method_name)
+                continue
+                
+            method = getattr(lsp_class, method_name)
+            if not callable(method):
+                missing_methods.append(method_name)
+                continue
+                
+            sig = inspect.signature(method)
+            method_params = [p for p in sig.parameters if p != 'self']
+            if len(method_params) != len(params):
+                missing_methods.append(f"{method_name}(parameter mismatch)")
+        
+        if missing_methods:
+            PrettyOutput.print(
+                f"LSP {lsp_class.__name__} is missing necessary methods: {', '.join(missing_methods)}", 
+                OutputType.ERROR
+            )
+            return False
+            
+        return True
+
+    @staticmethod
+    def load_lsp_from_dir(directory: str) -> Dict[str, Type[BaseLSP]]:
+        """Load LSP implementations from specified directory."""
+        lsp_servers = {}
+        
+        if not os.path.exists(directory):
+            PrettyOutput.print(f"LSP directory does not exist: {directory}", OutputType.ERROR)
+            return lsp_servers
+            
+        package_name = None
+        if directory == os.path.dirname(__file__):
+            package_name = "jarvis.jarvis_lsp"
+            
+        if directory not in sys.path:
+            sys.path.append(directory)
+        
+        for filename in os.listdir(directory):
+            if filename.endswith('.py') and not filename.startswith('__'):
+                module_name = filename[:-3]
+                try:
+                    if package_name:
+                        module = importlib.import_module(f"{package_name}.{module_name}")
+                    else:
+                        module = importlib.import_module(module_name)
+                    
+                    for _, obj in inspect.getmembers(module):
+                        if (inspect.isclass(obj) and 
+                            issubclass(obj, BaseLSP) and 
+                            obj != BaseLSP and
+                            hasattr(obj, 'language')):
+                            if not LSPRegistry.check_lsp_implementation(obj):
+                                continue
+                            if hasattr(obj, 'check'):
+                                if not obj.check(): # type: ignore
+                                    continue
+                            lsp_servers[obj.language] = obj
+                            break
+                except Exception as e:
+                    PrettyOutput.print(f"Load LSP {module_name} failed: {str(e)}", OutputType.ERROR)
+        
+        return lsp_servers
+
+    @staticmethod
+    def get_global_lsp_registry():
+        """Get global LSP registry instance."""
+        if LSPRegistry.global_lsp_registry is None:
+            LSPRegistry.global_lsp_registry = LSPRegistry()
+        return LSPRegistry.global_lsp_registry
+    
+    def __init__(self):
+        """Initialize LSP registry."""
+        self.lsp_servers: Dict[str, Type[BaseLSP]] = {}
+        
+        # Load from user LSP directory
+        lsp_dir = LSPRegistry.get_lsp_dir()
+        if lsp_dir and os.path.exists(lsp_dir):
+            for language, lsp_class in LSPRegistry.load_lsp_from_dir(lsp_dir).items():
+                self.register_lsp(language, lsp_class)
+                
+        # Load from built-in LSP directory
+        lsp_dir = os.path.dirname(__file__)
+        if lsp_dir and os.path.exists(lsp_dir):
+            for language, lsp_class in LSPRegistry.load_lsp_from_dir(lsp_dir).items():
+                self.register_lsp(language, lsp_class)
+
+    def register_lsp(self, language: str, lsp_class: Type[BaseLSP]):
+        """Register LSP implementation for a language."""
+        self.lsp_servers[language] = lsp_class
+            
+    def create_lsp(self, language: str) -> Optional[BaseLSP]:
+        """Create LSP instance for specified language."""
+        if language not in self.lsp_servers:
+            PrettyOutput.print(f"LSP not found for language: {language}", OutputType.ERROR)
+            return None
+            
+        try:
+            lsp = self.lsp_servers[language]()
+            return lsp
+        except Exception as e:
+            PrettyOutput.print(f"Create LSP failed: {str(e)}", OutputType.ERROR)
+            return None
+
+    def get_supported_languages(self) -> List[str]:
+        """Get list of supported languages."""
+        return list(self.lsp_servers.keys())
+    
+    @staticmethod
+    def get_text_at_position(file_path: str, line: int, start_character: int) -> str:
+        """Get text at position."""
+        with open(file_path, 'r') as file:
+            lines = file.readlines()
+            symbol = re.search(r'\b\w+\b', lines[line][start_character:])
+            return symbol.group() if symbol else ""
+        
+    @staticmethod
+    def get_line_at_position(file_path: str, line: int) -> str:
+        """Get line at position."""
+        with open(file_path, 'r') as file:
+            lines = file.readlines()
+            return lines[line]
+
+def main():
+    """CLI entry point for LSP testing."""
+    import argparse
+    
+    parser = argparse.ArgumentParser(description='LSP functionality testing')
+    parser.add_argument('--language', type=str, required=True, help='Programming language')
+    parser.add_argument('--file', type=str, required=True, help='File to analyze')
+    parser.add_argument('--action', choices=['symbols', 'diagnostics', 'references', 'definition'],
+                       required=True, help='Action to perform')
+    parser.add_argument('--line', type=int, help='Line number (0-based) for references/definition')
+    parser.add_argument('--character', type=int, help='Character position for references/definition')
+    
+    args = parser.parse_args()
+    
+    # Initialize LSP
+    registry = LSPRegistry.get_global_lsp_registry()
+    lsp = registry.create_lsp(args.language)
+    
+    if not lsp:
+        PrettyOutput.print(f"No LSP support for language: {args.language}", OutputType.ERROR)
+        return 1
+        
+    if not lsp.initialize(os.path.dirname(os.path.abspath(args.file))):
+        PrettyOutput.print("LSP initialization failed", OutputType.ERROR)
+        return 1
+    
+    try:
+        # Execute requested action
+        if args.action == 'symbols':
+            symbols = lsp.get_document_symbols(args.file)
+            for symbol in symbols:
+                print(f"Symbol {LSPRegistry.get_text_at_position(args.file, symbol['range']['start']['line'], symbol['range']['start']['character'])} at {symbol['range']['start']['line']}:{symbol['range']['start']['character']}: {symbol['uri']}")
+                
+        elif args.action == 'diagnostics':
+            diagnostics = lsp.get_diagnostics(args.file)
+            for diag in diagnostics:
+                severity = ['Error', 'Warning', 'Info', 'Hint'][diag['severity'] - 1]
+                print(f"{severity} at {diag['range']['start']['line']}:{diag['range']['start']['character']}: {diag['message']}")
+                
+        elif args.action in ('references', 'definition'):
+            if args.line is None or args.character is None:
+                PrettyOutput.print("Line and character position required for references/definition", OutputType.ERROR)
+                return 1
+                
+            if args.action == 'references':
+                refs = lsp.find_references(args.file, (args.line, args.character))
+                for ref in refs:
+                    print(f"Reference in {ref['uri']} at {ref['range']['start']['line']}:{ref['range']['start']['character']}\nLine: {LSPRegistry.get_line_at_position(ref['uri'], ref['range']['start']['line'])}")
+            else:
+                defn = lsp.find_definition(args.file, (args.line, args.character))
+                if defn:
+                    print(f"Definition in {defn['uri']} at {defn['range']['start']['line']}:{defn['range']['start']['character']}\nLine: {LSPRegistry.get_line_at_position(defn['uri'], defn['range']['start']['line'])}")
+                else:
+                    print("No definition found")
+                    
+    except Exception as e:
+        PrettyOutput.print(f"Error: {str(e)}", OutputType.ERROR)
+        return 1
+    finally:
+        lsp.shutdown()
+    
+    return 0
+
+if __name__ == "__main__":
+    exit(main())

jarvis/jarvis_lsp/rust.py

@@ -0,0 +1,142 @@
+import os
+import shutil
+import subprocess
+from typing import List, Dict, Optional, Tuple, Any
+import json
+from jarvis.jarvis_lsp.base import BaseLSP
+from jarvis.utils import PrettyOutput, OutputType
+
+class RustLSP(BaseLSP):
+    """Rust LSP implementation using rust-analyzer."""
+    
+    language = "rust"
+    
+    @staticmethod
+    def check() -> bool:
+        """Check if rust-analyzer is installed."""
+        return shutil.which("rust-analyzer") is not None
+    
+    def __init__(self):
+        self.workspace_path = ""
+        self.analyzer_process = None
+        self.request_id = 0
+    
+    def initialize(self, workspace_path: str) -> bool:
+        try:
+            self.workspace_path = workspace_path
+            # Start rust-analyzer process
+            self.analyzer_process = subprocess.Popen(
+                ["rust-analyzer"],
+                stdin=subprocess.PIPE,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE
+            )
+            
+            # Send initialize request
+            self._send_request("initialize", {
+                "processId": os.getpid(),
+                "rootUri": f"file://{workspace_path}",
+                "capabilities": {
+                    "textDocument": {
+                        "semanticTokens": {"full": True},
+                        "hover": {"contentFormat": ["markdown"]},
+                        "inlayHint": {"resolveSupport": {"properties": ["label.tooltip", "label.location", "label.command"]}},
+                        "completion": {"completionItem": {"snippetSupport": True}}
+                    }
+                },
+                "workspaceFolders": [{"uri": f"file://{workspace_path}", "name": "workspace"}]
+            })
+            
+            return True
+        except Exception as e:
+            PrettyOutput.print(f"Rust LSP initialization failed: {str(e)}", OutputType.ERROR)
+            return False
+    
+    def _send_request(self, method: str, params: Dict) -> Optional[Dict]:
+        """Send JSON-RPC request to rust-analyzer."""
+        if not self.analyzer_process:
+            return None
+            
+        try:
+            self.request_id += 1
+            request = {
+                "jsonrpc": "2.0",
+                "id": self.request_id,
+                "method": method,
+                "params": params
+            }
+            
+            self.analyzer_process.stdin.write(json.dumps(request).encode() + b"\n") # type: ignore
+            self.analyzer_process.stdin.flush() # type: ignore
+            
+            response = json.loads(self.analyzer_process.stdout.readline().decode()) # type: ignore
+            return response.get("result")
+        except Exception:
+            return None
+    
+    def find_references(self, file_path: str, position: Tuple[int, int]) -> List[Dict[str, Any]]:
+        result = self._send_request("textDocument/references", {
+            "textDocument": {"uri": f"file://{file_path}"},
+            "position": {"line": position[0], "character": position[1]},
+            "context": {"includeDeclaration": True}
+        })
+        return result or [] # type: ignore
+    
+    def find_definition(self, file_path: str, position: Tuple[int, int]) -> Optional[Dict[str, Any]]:
+        result = self._send_request("textDocument/definition", {
+            "textDocument": {"uri": f"file://{file_path}"},
+            "position": {"line": position[0], "character": position[1]}
+        })
+        return result[0] if result else None
+    
+    def get_document_symbols(self, file_path: str) -> List[Dict[str, Any]]:
+        result = self._send_request("textDocument/documentSymbol", {
+            "textDocument": {"uri": f"file://{file_path}"}
+        })
+        return result or [] # type: ignore
+    
+    def get_diagnostics(self, file_path: str) -> List[Dict[str, Any]]:
+        # Send didOpen notification to trigger diagnostics
+        self._send_request("textDocument/didOpen", {
+            "textDocument": {
+                "uri": f"file://{file_path}",
+                "languageId": "rust",
+                "version": 1,
+                "text": open(file_path).read()
+            }
+        })
+        
+        # Wait for diagnostic notification
+        try:
+            response = json.loads(self.analyzer_process.stdout.readline().decode()) # type: ignore
+            if response.get("method") == "textDocument/publishDiagnostics":
+                return response.get("params", {}).get("diagnostics", [])
+        except Exception:
+            pass
+        return []
+    
+    def prepare_rename(self, file_path: str, position: Tuple[int, int]) -> Optional[Dict[str, Any]]:
+        result = self._send_request("textDocument/prepareRename", {
+            "textDocument": {"uri": f"file://{file_path}"},
+            "position": {"line": position[0], "character": position[1]}
+        })
+        return result
+    
+    def validate_edit(self, file_path: str, edit: Dict[str, Any]) -> bool:
+        # Send workspace/willRenameFiles request to check validity
+        result = self._send_request("workspace/willRenameFiles", {
+            "files": [{
+                "oldUri": f"file://{file_path}",
+                "newUri": f"file://{file_path}.tmp"
+            }]
+        })
+        return bool(result)
+    
+    def shutdown(self):
+        if self.analyzer_process:
+            try:
+                self._send_request("shutdown", {})
+                self.analyzer_process.terminate()
+                self.analyzer_process = None
+            except Exception:
+                pass

jarvis/jarvis_platform/__init__.py

@@ -0,0 +1,3 @@
+from .base import BasePlatform
+
+__all__ = ['BasePlatform']     

jarvis/{models → jarvis_platform}/ai8.py

@@ -1,6 +1,6 @@
 import os
 from typing import Dict, List, Tuple
-from jarvis.models.base import BasePlatform
+from jarvis.jarvis_platform.base import BasePlatform
 from jarvis.utils import PrettyOutput, OutputType
 import requests
 import json

jarvis/{models → jarvis_platform}/kimi.py

@@ -4,7 +4,7 @@ import json
 import os
 import mimetypes
 import time
-from jarvis.models.base import BasePlatform
+from jarvis.jarvis_platform.base import BasePlatform
 from jarvis.utils import PrettyOutput, OutputType
 from jarvis.utils import while_success
 

jarvis/{models → jarvis_platform}/ollama.py

@@ -1,6 +1,6 @@
 import requests
 from typing import List, Dict, Tuple
-from jarvis.models.base import BasePlatform
+from jarvis.jarvis_platform.base import BasePlatform
 from jarvis.utils import OutputType, PrettyOutput, get_single_line_input
 import os
 import json