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

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,15 +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 get_diagnostics(self, file_path: str) -> List[Dict[str, Any]]:
         # Send didOpen notification to trigger diagnostics
         self._send_request("textDocument/didOpen", {
@@ -82,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
@@ -91,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,8 +24,8 @@ class PythonLSP(BaseLSP):
             except Exception:
                 return None
         return self.script_cache[file_path]
-    
-    
+
+
     def _location_to_dict(self, location) -> Dict[str, Any]:
         return {
             "uri": location.module_path,
@@ -34,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:
@@ -52,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

@@ -36,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]
@@ -85,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):
@@ -104,7 +104,7 @@ class LSPRegistry:
                             break
                 except Exception as e:
                     PrettyOutput.print(f"加载 LSP {module_name} 失败: {str(e)}", OutputType.ERROR)
-        
+
         return lsp_servers
 
     @staticmethod
@@ -113,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):
@@ -133,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
@@ -150,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."""
@@ -158,7 +158,7 @@ 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."""

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,16 +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 get_diagnostics(self, file_path: str) -> List[Dict[str, Any]]:
         # Send didOpen notification to trigger diagnostics
         self._send_request("textDocument/didOpen", {
@@ -85,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
@@ -94,8 +94,8 @@ class RustLSP(BaseLSP):
         except Exception:
             pass
         return []
-    
-    
+
+
     def shutdown(self):
         if self.analyzer_process:
             try:

jarvis/jarvis_methodology/main.py

@@ -0,0 +1,101 @@
+"""
+方法论导入导出命令行工具
+
+功能：
+- 导入方法论文件（合并策略）
+- 导出当前方法论
+- 列出所有方法论
+"""
+
+import hashlib
+import os
+import json
+import argparse
+from jarvis.jarvis_utils.methodology import (
+    _get_methodology_directory,
+    _load_all_methodologies
+)
+
+def import_methodology(input_file):
+    """导入方法论文件（合并策略）"""
+    try:
+        # 加载现有方法论
+        existing_methodologies = _load_all_methodologies()
+
+        # 加载要导入的方法论
+        with open(input_file, "r", encoding="utf-8") as f:
+            import_data = json.load(f)
+
+        # 合并方法论（新数据会覆盖旧数据）
+        merged_data = {**existing_methodologies, **import_data}
+
+        # 保存合并后的方法论
+        methodology_dir = _get_methodology_directory()
+        for problem_type, content in merged_data.items():
+            safe_filename = hashlib.md5(problem_type.encode('utf-8')).hexdigest()
+            file_path = os.path.join(methodology_dir, f"{safe_filename}.json")
+
+            with open(file_path, "w", encoding="utf-8") as f:
+                json.dump({
+                    "problem_type": problem_type,
+                    "content": content
+                }, f, ensure_ascii=False, indent=2)
+
+        print(f"成功导入 {len(import_data)} 个方法论（总计 {len(merged_data)} 个）")
+    except (json.JSONDecodeError, OSError) as e:
+        print(f"导入失败: {str(e)}")
+
+def export_methodology(output_file):
+    """导出当前方法论到单个文件"""
+    try:
+        methodologies = _load_all_methodologies()
+
+        with open(output_file, "w", encoding="utf-8") as f:
+            json.dump(methodologies, f, ensure_ascii=False, indent=2)
+
+        print(f"成功导出 {len(methodologies)} 个方法论到 {output_file}")
+    except (OSError, TypeError) as e:
+        print(f"导出失败: {str(e)}")
+
+def list_methodologies():
+    """列出所有方法论"""
+    try:
+        methodologies = _load_all_methodologies()
+
+        if not methodologies:
+            print("没有找到方法论")
+            return
+
+        print("可用方法论:")
+        for i, (problem_type, _) in enumerate(methodologies.items(), 1):
+            print(f"{i}. {problem_type}")
+    except (OSError, json.JSONDecodeError) as e:
+        print(f"列出方法论失败: {str(e)}")
+
+def main():
+    """方法论管理工具主函数"""
+    parser = argparse.ArgumentParser(description="方法论管理工具")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    # import命令
+    import_parser = subparsers.add_parser("import", help="导入方法论文件（合并策略）")
+    import_parser.add_argument("input_file", type=str, help="要导入的方法论文件路径")
+
+    # export命令
+    export_parser = subparsers.add_parser("export", help="导出当前方法论到单个文件")
+    export_parser.add_argument("output_file", type=str, help="导出文件路径")
+
+    # list命令
+    subparsers.add_parser("list", help="列出所有方法论")
+
+    args = parser.parse_args()
+
+    if args.command == "import":
+        import_methodology(args.input_file)
+    elif args.command == "export":
+        export_methodology(args.output_file)
+    elif args.command == "list":
+        list_methodologies()
+
+if __name__ == "__main__":
+    main()

jarvis/jarvis_multi_agent/__init__.py

@@ -35,16 +35,16 @@ class MultiAgent(OutputHandler):
 to: 智能体名称    # 目标智能体名称
 content: |
     # 消息主题
-    
+
     ## 背景信息
     [提供必要的上下文和背景]
-    
+
     ## 具体需求
     [明确表达期望完成的任务]
-    
+
     ## 相关资源
     [列出相关文档、数据或工具]
-    
+
     ## 期望结果
     [描述期望的输出格式和内容]
 
@@ -60,7 +60,7 @@ content: |
 to: 智能体名称    # 目标智能体名称
 content: |
     # 消息主题
-    
+
     ## 任务结果
     [任务完成结果，用于反馈]
 {ct("SEND_MESSAGE")}
@@ -74,22 +74,22 @@ content: |
         return len(self._extract_send_msg(response)) > 0
 
 
-    def handle(self, response: str) -> Tuple[bool, Any]:
+    def handle(self, response: str, agent: Any) -> Tuple[bool, Any]:
         send_messages = self._extract_send_msg(response)
         if len(send_messages) > 1:
             return False, f"Send multiple messages, please only send one message at a time."
         if len(send_messages) == 0:
             return False, ""
         return True, send_messages[0]
-        
+
     def name(self) -> str:
         return "SEND_MESSAGE"
-        
-    
+
+
     @staticmethod
     def _extract_send_msg(content: str) -> List[Dict]:
         """Extract send message from content.
-        
+
         Args:
             content: The content containing send message
         """
@@ -138,4 +138,4 @@ content: {msg['content']}
                 last_agent = self.agents[msg['to']].name
                 msg = self.agents[msg['to']].run(prompt)
         return ""
-    
+

jarvis/jarvis_multi_agent/main.py

@@ -5,7 +5,7 @@ from jarvis.jarvis_utils.input import get_multiline_input
 
 def main():
     """从YAML配置文件初始化并运行多智能体系统
-    
+
     Returns:
         最终处理结果
     """
@@ -15,25 +15,25 @@ def main():
     parser.add_argument("--config", "-c", required=True, help="YAML配置文件路径")
     parser.add_argument("--input", "-i", help="用户输入（可选）")
     args = parser.parse_args()
-        
+
     try:
         with open(args.config, 'r', errors="ignore") as f:
             config_data = yaml.safe_load(f)
-            
+
         # 获取agents配置
         agents_config = config_data.get('agents', [])
-        
+
         main_agent_name = config_data.get('main_agent', '')
         if not main_agent_name:
             raise ValueError("必须指定main_agent作为主智能体")
-            
+
         # 创建并运行多智能体系统
         multi_agent = MultiAgent(agents_config, main_agent_name)
         user_input = args.input if args.input is not None else get_multiline_input("请输入内容（输入空行结束）：")
         if user_input == "":
             return
         return multi_agent.run(user_input)
-        
+
     except yaml.YAMLError as e:
         raise ValueError(f"YAML配置文件解析错误: {str(e)}")
     except Exception as e:

jarvis/jarvis_platform/__init__.py

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