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

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

jarvis/jarvis_tools/lsp_get_diagnostics.py

@@ -1,147 +0,0 @@
-# -*- coding: utf-8 -*-
-import os
-from typing import Dict, Any
-from jarvis.jarvis_lsp.registry import LSPRegistry
-class LSPGetDiagnosticsTool:
-    """Tool for getting diagnostics (errors, warnings) from code using LSP."""
-
-    # 工具名称
-    name = "lsp_get_diagnostics"
-    # 工具描述
-    description = "Get diagnostic information (errors, warnings) from code files"
-    # 工具标签
-    # 工具参数定义
-    parameters = {
-        "file_path": "Path to the file to analyze",
-        "language": f"Programming language of the file ({', '.join(LSPRegistry.get_global_lsp_registry().get_supported_languages())})",
-        "root_dir": {
-            "type": "string",
-            "description": "Root directory for LSP operations (optional)",
-            "default": "."
-        }
-    }
-
-    @staticmethod
-    def check() -> bool:
-        """检查是否有可用的LSP服务器"""
-        registry = LSPRegistry.get_global_lsp_registry()
-        return len(registry.get_supported_languages()) > 0
-
-    def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
-        """执行工具的主要逻辑"""
-        file_path = args.get("file_path", "")
-        language = args.get("language", "")
-        root_dir = args.get("root_dir", ".")
-
-        # 验证输入参数
-        if not all([file_path, language]):
-            return {
-                "success": False,
-                "stderr": "Both file_path and language must be provided",
-                "stdout": ""
-            }
-
-        # 检查文件是否存在
-        if not os.path.exists(file_path):
-            return {
-                "success": False,
-                "stderr": f"File not found: {file_path}",
-                "stdout": ""
-            }
-
-        # 存储当前目录
-        original_dir = os.getcwd()
-
-        try:
-            # 切换到root_dir
-            os.chdir(root_dir)
-
-            # 获取LSP实例
-            registry = LSPRegistry.get_global_lsp_registry()
-            lsp = registry.create_lsp(language)
-
-            # 检查语言是否支持
-            if not lsp:
-                return {
-                    "success": False,
-                    "stderr": f"No LSP support for language: {language}",
-                    "stdout": ""
-                }
-
-            try:
-                # 初始化LSP
-                if not lsp.initialize(os.path.abspath(os.getcwd())):
-                    return {
-                        "success": False,
-                        "stderr": "LSP initialization failed",
-                        "stdout": ""
-                    }
-
-                # 获取诊断信息
-                diagnostics = lsp.get_diagnostics(file_path)
-
-                # 如果没有诊断信息
-                if not diagnostics:
-                    return {
-                        "success": True,
-                        "stdout": "No issues found in the file",
-                        "stderr": ""
-                    }
-
-                # 格式化输出
-                output = ["Diagnostics:"]
-                # 严重程度映射
-                severity_map = {1: "Error", 2: "Warning", 3: "Info", 4: "Hint"}
-
-                # 按严重程度和行号排序诊断信息
-                sorted_diagnostics = sorted(
-                    diagnostics,
-                    key=lambda x: (x["severity"], x["range"]["start"]["line"])
-                )
-
-                # 处理每个诊断信息
-                for diag in sorted_diagnostics:
-                    severity = severity_map.get(diag["severity"], "Unknown")
-                    start = diag["range"]["start"]
-                    line = LSPRegistry.get_line_at_position(file_path, start["line"]).strip()
-
-                    output.extend([
-                        f"\n{severity} at line {start['line'] + 1}, column {start['character'] + 1}:",
-                        f"Message: {diag['message']}",
-                        f"Code: {line}",
-                        "-" * 60
-                    ])
-
-                    # 处理相关附加信息
-                    if diag.get("relatedInformation"):
-                        output.append("Related information:")
-                        for info in diag["relatedInformation"]:
-                            info_line = LSPRegistry.get_line_at_position(
-                                info["location"]["uri"],
-                                info["location"]["range"]["start"]["line"]
-                            ).strip()
-                            output.extend([
-                                f"  - {info['message']}",
-                                f"    at {info['location']['uri']}:{info['location']['range']['start']['line'] + 1}",
-                                f"    {info_line}"
-                            ])
-
-                return {
-                    "success": True,
-                    "stdout": "\n".join(output),
-                    "stderr": ""
-                }
-
-            except Exception as e:
-                return {
-                    "success": False,
-                    "stderr": f"Error getting diagnostics: {str(e)}",
-                    "stdout": ""
-                }
-            finally:
-                # 确保关闭LSP连接
-                if lsp:
-                    lsp.shutdown()
-        finally:
-            # 恢复原始目录
-            os.chdir(original_dir)