jarvis-ai-assistant 0.1.130__py3-none-any.whl → 0.1.131__py3-none-any.whl

jarvis/jarvis_tools/lsp_find_definition.py

@@ -11,7 +11,12 @@ class LSPFindDefinitionTool:
         "file_path": "包含符号的文件路径",
         "line": "符号所在的行号（从0开始）",
         "character": "符号在行中的字符位置",
-        "language": f"文件的编程语言（{', '.join(LSPRegistry.get_global_lsp_registry().get_supported_languages())}）"
+        "language": f"文件的编程语言（{', '.join(LSPRegistry.get_global_lsp_registry().get_supported_languages())}）",
+        "root_dir": {
+            "type": "string",
+            "description": "LSP操作的根目录路径（可选）",
+            "default": "."
+        }
     }
     
     @staticmethod
@@ -26,6 +31,7 @@ class LSPFindDefinitionTool:
         line = args.get("line", None)
         character = args.get("character", None)
         language = args.get("language", "")
+        root_dir = args.get("root_dir", ".")
         
         # Validate inputs
         if not all([file_path, line is not None, character is not None, language]):
@@ -52,83 +58,93 @@ class LSPFindDefinitionTool:
                 "stdout": ""
             }
             
-        # Get LSP instance
-        registry = LSPRegistry.get_global_lsp_registry()
-        lsp = registry.create_lsp(language)
+        # Store current directory
+        original_dir = os.getcwd()
         
-        if not lsp:
-            return {
-                "success": False,
-                "stderr": f"No LSP support for language: {language}",
-                "stdout": ""
-            }
-            
         try:
-            # Initialize LSP
-            if not lsp.initialize(os.path.abspath(os.getcwd())):
+            # Change to root_dir
+            os.chdir(root_dir)
+            
+            # Get LSP instance
+            registry = LSPRegistry.get_global_lsp_registry()
+            lsp = registry.create_lsp(language)
+            
+            if not lsp:
                 return {
                     "success": False,
-                    "stderr": "LSP initialization failed",
+                    "stderr": f"No LSP support for language: {language}",
                     "stdout": ""
                 }
                 
-            # Get symbol at position
-            symbol = LSPRegistry.get_text_at_position(file_path, line, character)
-            if not symbol:
-                return {
-                    "success": False,
-                    "stderr": f"No symbol found at position {line}:{character}",
-                    "stdout": ""
-                }
+            try:
+                # Initialize LSP
+                if not lsp.initialize(os.path.abspath(os.getcwd())):
+                    return {
+                        "success": False,
+                        "stderr": "LSP initialization failed",
+                        "stdout": ""
+                    }
+                    
+                # Get symbol at position
+                symbol = LSPRegistry.get_text_at_position(file_path, line, character)
+                if not symbol:
+                    return {
+                        "success": False,
+                        "stderr": f"No symbol found at position {line}:{character}",
+                        "stdout": ""
+                    }
+                    
+                # Find definition
+                defn = lsp.find_definition(file_path, (line, character))
+                
+                if not defn:
+                    return {
+                        "success": True,
+                        "stdout": f"No definition found for '{symbol}'",
+                        "stderr": ""
+                    }
+                    
+                # Format output
+                def_line = defn["range"]["start"]["line"]
+                def_char = defn["range"]["start"]["character"]
+                context = LSPRegistry.get_line_at_position(defn["uri"], def_line).strip()
+                
+                output = [
+                    f"Definition of '{symbol}':",
+                    f"File: {defn['uri']}",
+                    f"Line {def_line + 1}, Col {def_char + 1}: {context}"
+                ]
+                
+                # Get a few lines of context around the definition
+                try:
+                    with open(defn["uri"], 'r', errors="ignore") as f:
+                        lines = f.readlines()
+                        start = max(0, def_line - 2)
+                        end = min(len(lines), def_line + 3)
+                        
+                        if start < def_line:
+                            output.append("\nContext:")
+                            for i in range(start, end):
+                                prefix = ">" if i == def_line else " "
+                                output.append(f"{prefix} {i+1:4d} | {lines[i].rstrip()}")
+                except Exception:
+                    pass
                 
-            # Find definition
-            defn = lsp.find_definition(file_path, (line, character))
-            
-            if not defn:
                 return {
                     "success": True,
-                    "stdout": f"No definition found for '{symbol}'",
+                    "stdout": "\n".join(output),
                     "stderr": ""
                 }
                 
-            # Format output
-            def_line = defn["range"]["start"]["line"]
-            def_char = defn["range"]["start"]["character"]
-            context = LSPRegistry.get_line_at_position(defn["uri"], def_line).strip()
-            
-            output = [
-                f"Definition of '{symbol}':",
-                f"File: {defn['uri']}",
-                f"Line {def_line + 1}, Col {def_char + 1}: {context}"
-            ]
-            
-            # Get a few lines of context around the definition
-            try:
-                with open(defn["uri"], 'r') as f:
-                    lines = f.readlines()
-                    start = max(0, def_line - 2)
-                    end = min(len(lines), def_line + 3)
-                    
-                    if start < def_line:
-                        output.append("\nContext:")
-                        for i in range(start, end):
-                            prefix = ">" if i == def_line else " "
-                            output.append(f"{prefix} {i+1:4d} | {lines[i].rstrip()}")
-            except Exception:
-                pass
-            
-            return {
-                "success": True,
-                "stdout": "\n".join(output),
-                "stderr": ""
-            }
-            
-        except Exception as e:
-            return {
-                "success": False,
-                "stderr": f"Error finding definition: {str(e)}",
-                "stdout": ""
-            }
+            except Exception as e:
+                return {
+                    "success": False,
+                    "stderr": f"Error finding definition: {str(e)}",
+                    "stdout": ""
+                }
+            finally:
+                if lsp:
+                    lsp.shutdown()
         finally:
-            if lsp:
-                lsp.shutdown()
+            # Always restore original directory
+            os.chdir(original_dir)

jarvis/jarvis_tools/lsp_find_references.py

@@ -11,7 +11,12 @@ class LSPFindReferencesTool:
         "file_path": "Path to the file containing the symbol",
         "line": "Line number (0-based) of the symbol",
         "character": "Character position in the line",
-        "language": f"Programming language of the file ({', '.join(LSPRegistry.get_global_lsp_registry().get_supported_languages())})"
+        "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
@@ -26,6 +31,7 @@ class LSPFindReferencesTool:
         line = args.get("line", None)
         character = args.get("character", None)
         language = args.get("language", "")
+        root_dir = args.get("root_dir", ".")
         
         # Validate inputs
         if not all([file_path, line is not None, character is not None, language]):
@@ -52,60 +58,70 @@ class LSPFindReferencesTool:
                 "stdout": ""
             }
             
-        # Get LSP instance
-        registry = LSPRegistry.get_global_lsp_registry()
-        lsp = registry.create_lsp(language)
+        # Store current directory
+        original_dir = os.getcwd()
         
-        if not lsp:
-            return {
-                "success": False,
-                "stderr": f"No LSP support for language: {language}",
-                "stdout": ""
-            }
-            
         try:
-            # Initialize LSP
-            if not lsp.initialize(os.path.abspath(os.getcwd())):
+            # Change to root_dir
+            os.chdir(root_dir)
+            
+            # Get LSP instance
+            registry = LSPRegistry.get_global_lsp_registry()
+            lsp = registry.create_lsp(language)
+            
+            if not lsp:
                 return {
                     "success": False,
-                    "stderr": "LSP initialization failed",
+                    "stderr": f"No LSP support for language: {language}",
                     "stdout": ""
                 }
                 
-            # Get symbol at position
-            symbol = LSPRegistry.get_text_at_position(file_path, line, character)
-            if not symbol:
+            try:
+                # Initialize LSP
+                if not lsp.initialize(os.path.abspath(os.getcwd())):
+                    return {
+                        "success": False,
+                        "stderr": "LSP initialization failed",
+                        "stdout": ""
+                    }
+                    
+                # Get symbol at position
+                symbol = LSPRegistry.get_text_at_position(file_path, line, character)
+                if not symbol:
+                    return {
+                        "success": False,
+                        "stderr": f"No symbol found at position {line}:{character}",
+                        "stdout": ""
+                    }
+                    
+                # Find references
+                refs = lsp.find_references(file_path, (line, character))
+                
+                # Format output
+                output = [f"References to '{symbol}':\n"]
+                for ref in refs:
+                    ref_line = ref["range"]["start"]["line"]
+                    ref_char = ref["range"]["start"]["character"]
+                    context = LSPRegistry.get_line_at_position(ref["uri"], ref_line).strip()
+                    output.append(f"File: {ref['uri']}")
+                    output.append(f"Line {ref_line + 1}, Col {ref_char + 1}: {context}")
+                    output.append("-" * 40)
+                
+                return {
+                    "success": True,
+                    "stdout": "\n".join(output) if len(refs) > 0 else f"No references found for '{symbol}'",
+                    "stderr": ""
+                }
+                
+            except Exception as e:
                 return {
                     "success": False,
-                    "stderr": f"No symbol found at position {line}:{character}",
+                    "stderr": f"Error finding references: {str(e)}",
                     "stdout": ""
                 }
-                
-            # Find references
-            refs = lsp.find_references(file_path, (line, character))
-            
-            # Format output
-            output = [f"References to '{symbol}':\n"]
-            for ref in refs:
-                ref_line = ref["range"]["start"]["line"]
-                ref_char = ref["range"]["start"]["character"]
-                context = LSPRegistry.get_line_at_position(ref["uri"], ref_line).strip()
-                output.append(f"File: {ref['uri']}")
-                output.append(f"Line {ref_line + 1}, Col {ref_char + 1}: {context}")
-                output.append("-" * 40)
-            
-            return {
-                "success": True,
-                "stdout": "\n".join(output) if len(refs) > 0 else f"No references found for '{symbol}'",
-                "stderr": ""
-            }
-            
-        except Exception as e:
-            return {
-                "success": False,
-                "stderr": f"Error finding references: {str(e)}",
-                "stdout": ""
-            }
+            finally:
+                if lsp:
+                    lsp.shutdown()
         finally:
-            if lsp:
-                lsp.shutdown()
+            # Always restore original directory
+            os.chdir(original_dir)

jarvis/jarvis_tools/lsp_get_diagnostics.py

@@ -11,7 +11,12 @@ class LSPGetDiagnosticsTool:
     # 工具参数定义
     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())})"
+        "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
@@ -24,6 +29,7 @@ class LSPGetDiagnosticsTool:
         """执行工具的主要逻辑"""
         file_path = args.get("file_path", "")
         language = args.get("language", "")
+        root_dir = args.get("root_dir", ".")
         
         # 验证输入参数
         if not all([file_path, language]):
@@ -41,89 +47,99 @@ class LSPGetDiagnosticsTool:
                 "stdout": ""
             }
             
-        # 获取LSP实例
-        registry = LSPRegistry.get_global_lsp_registry()
-        lsp = registry.create_lsp(language)
+        # 存储当前目录
+        original_dir = os.getcwd()
         
-        # 检查语言是否支持
-        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())):
+            # 切换到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": "LSP initialization failed",
+                    "stderr": f"No LSP support for language: {language}",
                     "stdout": ""
                 }
                 
-            # 获取诊断信息
-            diagnostics = lsp.get_diagnostics(file_path)
-            
-            # 如果没有诊断信息
-            if not diagnostics:
+            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": "No issues found in the file",
+                    "stdout": "\n".join(output),
                     "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": ""
-            }
+            except Exception as e:
+                return {
+                    "success": False,
+                    "stderr": f"Error getting diagnostics: {str(e)}",
+                    "stdout": ""
+                }
+            finally:
+                # 确保关闭LSP连接
+                if lsp:
+                    lsp.shutdown()
         finally:
-            # 确保关闭LSP连接
-            if lsp:
-                lsp.shutdown()
+            # 恢复原始目录
+            os.chdir(original_dir)

jarvis/jarvis_tools/methodology.py

@@ -47,7 +47,7 @@ class MethodologyTool:
         """Ensure the methodology file exists"""
         if not os.path.exists(self.methodology_file):
             try:
-                with open(self.methodology_file, 'w', encoding='utf-8') as f:
+                with open(self.methodology_file, 'w', encoding='utf-8', errors="ignore") as f:
                     yaml.safe_dump({}, f, allow_unicode=True)
             except Exception as e:
                 PrettyOutput.print(f"创建方法论文件失败：{str(e)}", OutputType.ERROR)
@@ -55,7 +55,7 @@ class MethodologyTool:
     def _load_methodologies(self) -> Dict:
         """Load all methodologies"""
         try:
-            with open(self.methodology_file, 'r', encoding='utf-8') as f:
+            with open(self.methodology_file, 'r', encoding='utf-8', errors="ignore") as f:
                 return yaml.safe_load(f) or {}
         except Exception as e:
             PrettyOutput.print(f"加载方法论失败: {str(e)}", OutputType.ERROR)
@@ -64,7 +64,7 @@ class MethodologyTool:
     def _save_methodologies(self, methodologies: Dict):
         """Save all methodologies"""
         try:
-            with open(self.methodology_file, 'w', encoding='utf-8') as f:
+            with open(self.methodology_file, 'w', encoding='utf-8', errors="ignore") as f:
                 yaml.safe_dump(methodologies, f, allow_unicode=True)
         except Exception as e:
             PrettyOutput.print(f"保存方法论失败: {str(e)}", OutputType.ERROR)

jarvis/jarvis_tools/read_code.py

@@ -49,7 +49,7 @@ class ReadCodeTool:
                     }
                 
                 # 读取文件内容
-                with open(abs_path, 'r', encoding='utf-8') as f:
+                with open(abs_path, 'r', encoding='utf-8', errors="ignore") as f:
                     lines = f.readlines()
                 
                 total_lines = len(lines)

jarvis/jarvis_tools/search_web.py

@@ -168,22 +168,20 @@ class SearchTool:
             # Process each batch
             batch_results = []
             for i, batch in enumerate(batches, 1):
-                PrettyOutput.print(f"正在处理批次 {i}/{len(batches)}...", OutputType.PROGRESS)
-                
-                prompt = f"""Please analyze these search results to answer the question: {question}
+                prompt = f"""请根据以下搜索结果回答以下问题：{question}
 
-Search results content (Batch {i}/{len(batches)}):
+搜索结果内容 (第 {i} 批/{len(batches)}):
 {'-' * 40}
 {''.join(batch)}
 {'-' * 40}
 
-Please extract key information related to the question. Focus on:
-1. Relevant facts and details
-2. Maintaining objectivity
-3. Citing sources when appropriate
-4. Noting any uncertainties
+请提取与问题相关的关键信息。重点关注：
+1. 相关事实和细节
+2. 保持客观性
+3. 在适当的时候引用来源
+4. 注明任何不确定性
 
-Format your response as a clear summary of findings from this batch."""
+请将您的回答格式化为对本批次搜索结果的清晰总结。"""
 
                 response = self.model.chat_until_success(prompt)
                 batch_results.append(response)
@@ -196,27 +194,27 @@ Format your response as a clear summary of findings from this batch."""
             batch_findings = '\n\n'.join(f'Batch {i+1}:\n{result}' for i, result in enumerate(batch_results))
             separator = '-' * 40
             
-            synthesis_prompt = f"""Please provide a comprehensive answer to the original question by synthesizing the findings from multiple batches of search results.
+            synthesis_prompt = f"""请通过综合多个批次的搜索结果，为原始问题提供一个全面的回答。
 
-Original Question: {question}
+原始问题: {question}
 
-Findings from each batch:
+各批次的发现:
 {separator}
 {batch_findings}
 {separator}
 
-Please synthesize a final answer that:
-1. Combines key insights from all batches
-2. Resolves any contradictions between sources
-3. Maintains clear source attribution
-4. Acknowledges any remaining uncertainties
-5. Provides a coherent and complete response to the original question"""
+请综合出一个最终答案，要求：
+1. 整合所有批次的关键见解
+2. 解决不同来源之间的矛盾
+3. 保持清晰的来源归属
+4. 承认任何剩余的不确定性
+5. 提供对原始问题的连贯完整的回答"""
 
             final_response = self.model.chat_until_success(synthesis_prompt)
             return final_response
 
         except Exception as e:
-            return f"Information extraction failed: {str(e)}"
+            return f"信息提取失败：{str(e)}"
 
     def execute(self, args: Dict) -> Dict[str, Any]:
         """Execute search and extract information"""

jarvis/jarvis_tools/tool_generator.py

@@ -84,7 +84,7 @@ class ToolGenerator:
                 tools_dir.mkdir(parents=True, exist_ok=True)
                 tool_file = tools_dir / f"{tool_name}.py"
                 
-                with open(tool_file, "w") as f:
+                with open(tool_file, "w", errors="ignore") as f:
                     f.write(implementation)
                 spinner.text = "工具保存完成"
                 spinner.ok("✅")