jarvis-ai-assistant 0.1.177__py3-none-any.whl → 0.1.178__py3-none-any.whl

jarvis/jarvis_lsp/base.py

@@ -1,66 +0,0 @@
-# -*- coding: utf-8 -*-
-from abc import ABC, abstractmethod
-from typing import List, Dict, Any, Union
-
-class BaseLSP(ABC):
-    """Base class for Language Server Protocol integration.
-
-    Core LSP features needed for LLM-based code editing:
-    1. Code navigation and analysis
-    2. Code modification validation
-    3. Diagnostic information
-    4. Symbol analysis
-    """
-
-    language: Union[str, List[str]] = ""  # Language identifier, should be overridden by subclasses
-
-    @abstractmethod
-    def initialize(self, workspace_path: str) -> bool:
-        """Initialize LSP server for the workspace.
-
-        Args:
-            workspace_path: Root path of the workspace
-
-        Returns:
-            bool: True if initialization successful
-        """
-        return False
-
-
-    @abstractmethod
-    def get_diagnostics(self, file_path: str) -> List[Dict[str, Any]]:
-        """Get diagnostics (errors, warnings) for file.
-
-        Args:
-            file_path: Path to the file
-
-        Returns:
-            List of diagnostic items:
-            [
-                {
-                    "range": {
-                        "start": {"line": int, "character": int},
-                        "end": {"line": int, "character": int}
-                    },
-                    "severity": 1 | 2 | 3 | 4,  # Error=1, Warning=2, Info=3, Hint=4
-                    "code": str,                # Error code if any
-                    "source": str,             # Source of diagnostic (e.g. "pylint")
-                    "message": str,            # Diagnostic message
-                    "relatedInformation": [    # Optional related info
-                        {
-                            "location": {
-                                "uri": str,
-                                "range": {...}
-                            },
-                            "message": str
-                        }
-                    ]
-                }
-            ]
-        """
-        return []
-
-
-    def shutdown(self):
-        """Shutdown LSP server cleanly."""
-        pass

jarvis/jarvis_lsp/cpp.py

@@ -1,99 +0,0 @@
-# -*- coding: utf-8 -*-
-import os
-import shutil
-import subprocess
-from typing import List, Dict, Optional, Any
-import json
-from jarvis.jarvis_lsp.base import BaseLSP
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
-
-class CPPLSP(BaseLSP):
-    """C++ LSP implementation using clangd."""
-
-    language = ["cpp", "c"]
-
-    @staticmethod
-    def check() -> bool:
-        """Check if clangd is installed."""
-        return shutil.which("clangd") is not None
-
-    def __init__(self):
-        self.workspace_path = ""
-        self.clangd_process = None
-        self.request_id = 0
-
-    def initialize(self, workspace_path: str) -> bool:
-        try:
-            self.workspace_path = workspace_path
-            # Start clangd process
-            self.clangd_process = subprocess.Popen(
-                ["clangd", "--background-index"],
-                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": {}
-            })
-
-            return True
-        except Exception as e:
-            PrettyOutput.print(f"C++ LSP 初始化失败: {str(e)}", OutputType.ERROR)
-            return False
-
-    def _send_request(self, method: str, params: Dict) -> Optional[Dict]:
-        """Send JSON-RPC request to clangd."""
-        if not self.clangd_process:
-            return None
-
-        try:
-            self.request_id += 1
-            request = {
-                "jsonrpc": "2.0",
-                "id": self.request_id,
-                "method": method,
-                "params": params
-            }
-
-            self.clangd_process.stdin.write(json.dumps(request).encode() + b"\n") # type: ignore
-            self.clangd_process.stdin.flush() # type: ignore
-
-            response = json.loads(self.clangd_process.stdout.readline().decode()) # type: ignore
-            return response.get("result")
-        except Exception:
-            return None
-
-
-    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": "cpp",
-                "version": 1,
-                "text": open(file_path).read()
-            }
-        })
-
-        # Wait for diagnostic notification
-        try:
-            response = json.loads(self.clangd_process.stdout.readline().decode()) # type: ignore
-            if response.get("method") == "textDocument/publishDiagnostics":
-                return response.get("params", {}).get("diagnostics", [])
-        except Exception:
-            pass
-        return []
-
-
-    def shutdown(self):
-        if self.clangd_process:
-            try:
-                self._send_request("shutdown", {})
-                self.clangd_process.terminate()
-                self.clangd_process = None
-            except Exception:
-                pass

jarvis/jarvis_lsp/go.py

@@ -1,104 +0,0 @@
-# -*- coding: utf-8 -*-
-import os
-import shutil
-import subprocess
-from typing import List, Dict, Optional, Any
-import json
-from jarvis.jarvis_lsp.base import BaseLSP
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
-
-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 初始化失败: {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 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 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

@@ -1,58 +0,0 @@
-# -*- coding: utf-8 -*-
-from typing import List, Dict, Any
-import jedi
-from jarvis.jarvis_lsp.base import BaseLSP
-
-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', errors="ignore") 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 _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_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 shutdown(self):
-        self.script_cache.clear()

jarvis/jarvis_lsp/registry.py

@@ -1,169 +0,0 @@
-# -*- coding: utf-8 -*-
-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.jarvis_utils.output import OutputType, PrettyOutput
-from jarvis.jarvis_utils.config import get_data_dir
-
-REQUIRED_METHODS = [
-    ('initialize', ['workspace_path']),
-    ('get_diagnostics', ['file_path']),
-    ('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.join(get_data_dir(), "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", errors="ignore") as f:
-                    pass
-            except Exception as e:
-                PrettyOutput.print(f"创建 LSP 目录失败: {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__} 缺少必要的方法: {', '.join(missing_methods)}",
-                OutputType.WARNING
-            )
-            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}", OutputType.WARNING)
-            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
-                            if isinstance(obj.language, str):
-                                lsp_servers[obj.language] = obj
-                            elif isinstance(obj.language, list):
-                                for lang in obj.language: # type: ignore
-                                    lsp_servers[lang] = obj
-                            break
-                except Exception as e:
-                    PrettyOutput.print(f"加载 LSP {module_name} 失败: {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 支持的语言: {language}", OutputType.WARNING)
-            return None
-
-        try:
-            lsp = self.lsp_servers[language]()
-            return lsp
-        except Exception as e:
-            PrettyOutput.print(f"创建 LSP 失败: {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', errors="ignore") 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', errors="ignore") as file:
-            lines = file.readlines()
-            return lines[line]

jarvis/jarvis_lsp/rust.py

@@ -1,107 +0,0 @@
-# -*- coding: utf-8 -*-
-import os
-import shutil
-import subprocess
-from typing import List, Dict, Optional, Any
-import json
-from jarvis.jarvis_lsp.base import BaseLSP
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
-
-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 初始化失败: {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 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 shutdown(self):
-        if self.analyzer_process:
-            try:
-                self._send_request("shutdown", {})
-                self.analyzer_process.terminate()
-                self.analyzer_process = None
-            except Exception:
-                pass