jarvis-ai-assistant 0.1.132__py3-none-any.whl → 0.1.138__py3-none-any.whl

jarvis/jarvis_lsp/cpp.py

@@ -8,19 +8,19 @@ 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
@@ -31,24 +31,24 @@ class CPPLSP(BaseLSP):
                 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 = {
@@ -57,31 +57,16 @@ class CPPLSP(BaseLSP):
                 "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 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_diagnostics(self, file_path: str) -> List[Dict[str, Any]]:
         # Send didOpen notification to trigger diagnostics
         self._send_request("textDocument/didOpen", {
@@ -92,7 +77,7 @@ class CPPLSP(BaseLSP):
                 "text": open(file_path).read()
             }
         })
-        
+
         # Wait for diagnostic notification
         try:
             response = json.loads(self.clangd_process.stdout.readline().decode()) # type: ignore
@@ -101,8 +86,8 @@ class CPPLSP(BaseLSP):
         except Exception:
             pass
         return []
-    
-    
+
+
     def shutdown(self):
         if self.clangd_process:
             try:

jarvis/jarvis_lsp/go.py

@@ -8,19 +8,19 @@ 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
@@ -31,7 +31,7 @@ class GoLSP(BaseLSP):
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE
             )
-            
+
             # Send initialize request
             self._send_request("initialize", {
                 "processId": os.getpid(),
@@ -44,17 +44,17 @@ class GoLSP(BaseLSP):
                     }
                 }
             })
-            
+
             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 = {
@@ -63,30 +63,15 @@ class GoLSP(BaseLSP):
                 "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_diagnostics(self, file_path: str) -> List[Dict[str, Any]]:
         # Send didOpen notification to trigger diagnostics
         self._send_request("textDocument/didOpen", {
@@ -97,7 +82,7 @@ class GoLSP(BaseLSP):
                 "text": open(file_path).read()
             }
         })
-        
+
         # Wait for diagnostic notification
         try:
             response = json.loads(self.gopls_process.stdout.readline().decode()) # type: ignore
@@ -106,8 +91,8 @@ class GoLSP(BaseLSP):
         except Exception:
             pass
         return []
-    
-    
+
+
     def shutdown(self):
         if self.gopls_process:
             try:

jarvis/jarvis_lsp/python.py

@@ -4,17 +4,17 @@ 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:
@@ -24,27 +24,8 @@ class PythonLSP(BaseLSP):
             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,
@@ -53,7 +34,7 @@ class PythonLSP(BaseLSP):
                 "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:
@@ -71,6 +52,6 @@ class PythonLSP(BaseLSP):
             } for e in errors]
         except Exception:
             return []
-    
+
     def shutdown(self):
         self.script_cache.clear()

jarvis/jarvis_lsp/registry.py

@@ -9,8 +9,6 @@ from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 REQUIRED_METHODS = [
     ('initialize', ['workspace_path']),
-    ('find_references', ['file_path', 'position']),
-    ('find_definition', ['file_path', 'position']),
     ('get_diagnostics', ['file_path']),
     ('shutdown', [])
 ]
@@ -38,47 +36,47 @@ class LSPRegistry:
     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)}", 
+                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]
@@ -87,10 +85,10 @@ class LSPRegistry:
                         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 
+                        if (inspect.isclass(obj) and
+                            issubclass(obj, BaseLSP) and
                             obj != BaseLSP and
                             hasattr(obj, 'language')):
                             if not LSPRegistry.check_lsp_implementation(obj):
@@ -106,7 +104,7 @@ class LSPRegistry:
                             break
                 except Exception as e:
                     PrettyOutput.print(f"加载 LSP {module_name} 失败: {str(e)}", OutputType.ERROR)
-        
+
         return lsp_servers
 
     @staticmethod
@@ -115,17 +113,17 @@ class LSPRegistry:
         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):
@@ -135,13 +133,13 @@ class LSPRegistry:
     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
@@ -152,7 +150,7 @@ class LSPRegistry:
     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."""
@@ -160,70 +158,10 @@ class LSPRegistry:
             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]
-
-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"没有 LSP 支持的语言: {args.language}", OutputType.WARNING)
-        return 1
-        
-    if not lsp.initialize(os.path.abspath(os.getcwd())):
-        PrettyOutput.print("LSP 初始化失败", OutputType.WARNING)
-        return 1
-    
-    try:        
-        if args.action == 'diagnostics':
-            diagnostics = lsp.get_diagnostics(args.file)
-            for diag in diagnostics:
-                severity = ['Error', 'Warning', 'Info', 'Hint'][diag['severity'] - 1]
-                PrettyOutput.print(f"{severity} 在 {diag['range']['start']['line']}:{diag['range']['start']['character']}: {diag['message']}", OutputType.INFO)
-                
-        elif args.action in ('references', 'definition'):
-            if args.line is None or args.character is None:
-                PrettyOutput.print("需要行和字符位置用于 references/definition", OutputType.WARNING)
-                return 1
-                
-            if args.action == 'references':
-                refs = lsp.find_references(args.file, (args.line, args.character))
-                for ref in refs:
-                    PrettyOutput.print(f"引用在 {ref['uri']} 在 {ref['range']['start']['line']}:{ref['range']['start']['character']}\n行: {LSPRegistry.get_line_at_position(ref['uri'], ref['range']['start']['line'])}", OutputType.INFO)
-            else:
-                defn = lsp.find_definition(args.file, (args.line, args.character))
-                if defn:
-                    PrettyOutput.print(f"定义在 {defn['uri']} 在 {defn['range']['start']['line']}:{defn['range']['start']['character']}\n行: {LSPRegistry.get_line_at_position(defn['uri'], defn['range']['start']['line'])}", OutputType.INFO)
-                else:
-                    PrettyOutput.print("没有找到定义", OutputType.WARNING)
-                    
-    except Exception as e:
-        PrettyOutput.print(f"错误: {str(e)}", OutputType.ERROR)
-        return 1
-    finally:
-        lsp.shutdown()
-    
-    return 0
-
-if __name__ == "__main__":
-    exit(main())

jarvis/jarvis_lsp/rust.py

@@ -8,19 +8,19 @@ 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
@@ -31,7 +31,7 @@ class RustLSP(BaseLSP):
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE
             )
-            
+
             # Send initialize request
             self._send_request("initialize", {
                 "processId": os.getpid(),
@@ -46,17 +46,17 @@ class RustLSP(BaseLSP):
                 },
                 "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 = {
@@ -65,31 +65,16 @@ class RustLSP(BaseLSP):
                 "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_diagnostics(self, file_path: str) -> List[Dict[str, Any]]:
         # Send didOpen notification to trigger diagnostics
         self._send_request("textDocument/didOpen", {
@@ -100,7 +85,7 @@ class RustLSP(BaseLSP):
                 "text": open(file_path).read()
             }
         })
-        
+
         # Wait for diagnostic notification
         try:
             response = json.loads(self.analyzer_process.stdout.readline().decode()) # type: ignore
@@ -109,8 +94,8 @@ class RustLSP(BaseLSP):
         except Exception:
             pass
         return []
-    
-    
+
+
     def shutdown(self):
         if self.analyzer_process:
             try: