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

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)
@@ -84,7 +84,7 @@ class ReadCodeTool:
                     f"{numbered_content}\n"
                     f"{'='*80}\n"
                 )
-                
+                spinner.text = f"文件读取完成: {abs_path}"
                 spinner.ok("✅")
                 return {
                     "success": True,

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("✅")

jarvis/jarvis_tools/treesitter_analyzer.py

@@ -0,0 +1,331 @@
+from typing import Dict, Any, List, Optional
+import os
+import logging
+from yaspin import yaspin
+
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+from jarvis.jarvis_treesitter import (
+    CodeDatabase, 
+    SymbolType, 
+    setup_default_grammars,
+    DEFAULT_GRAMMAR_DIR
+)
+
+# 配置日志
+logger = logging.getLogger(__name__)
+
+class TreesitterAnalyzer:
+    """Tree-sitter 代码分析工具，用于快速查找代码中的符号定义、引用和调用关系"""
+    
+    name = "treesitter_analyzer"
+    description = "使用 Tree-sitter 分析代码，查找符号定义、引用和调用关系"
+    parameters = {
+        "type": "object",
+        "properties": {
+            "action": {
+                "type": "string",
+                "enum": ["find_symbol", "find_references", "find_callers"],
+                "description": "分析操作类型: find_symbol(查找符号), find_references(查找引用), find_callers(查找调用者)"
+            },
+            "symbol_name": {
+                "type": "string",
+                "description": "要查找的符号名称，如函数名、类名、变量名等"
+            },
+            "directory": {
+                "type": "string",
+                "description": "要索引的代码目录，默认为当前目录",
+                "default": "."
+            },
+            "extensions": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "要索引的文件扩展名列表，如 [\".py\", \".c\"]，不指定则索引所有支持的文件类型"
+            },
+            "max_results": {
+                "type": "integer",
+                "description": "最大返回结果数量",
+                "default": 20
+            }
+        },
+        "required": ["action", "symbol_name", "directory"]
+    }
+    
+    def __init__(self):
+        """初始化 Tree-sitter 分析器工具"""
+        # 确保语法文件目录存在
+        os.makedirs(DEFAULT_GRAMMAR_DIR, exist_ok=True)
+        
+        # 创建代码数据库实例
+        self.db = None
+        
+    def _get_database(self) -> CodeDatabase:
+        """获取 Tree-sitter 代码数据库实例，如果不存在则创建"""
+        if self.db is None:
+            self.db = CodeDatabase()
+        return self.db
+    
+    def _index_directory(self, directory: str, extensions: Optional[List[str]] = None) -> Dict[str, Any]:
+        """索引指定目录下的代码文件"""
+        try:
+            db = self._get_database()
+            indexed_files = []
+            skipped_files = []
+            
+            with yaspin(text=f"正在索引目录: {directory}...", color="cyan") as spinner:
+                for root, _, files in os.walk(directory):
+                    for file in files:
+                        # 检查文件扩展名
+                        if extensions and not any(file.endswith(ext) for ext in extensions):
+                            continue
+                            
+                        file_path = os.path.join(root, file)
+                        try:
+                            db.index_file(file_path)
+                            indexed_files.append(file_path)
+                        except Exception as e:
+                            skipped_files.append((file_path, str(e)))
+                
+                spinner.text = f"索引完成: {len(indexed_files)} 个文件"
+                spinner.ok("✅")
+                
+                return {
+                    "success": True,
+                    "indexed_files": indexed_files,
+                    "skipped_files": skipped_files,
+                    "index_summary": f"已成功索引 {len(indexed_files)} 个文件，跳过 {len(skipped_files)} 个文件"
+                }
+                
+        except Exception as e:
+            logger.error(f"索引目录失败: {str(e)}")
+            return {
+                "success": False,
+                "stderr": f"索引目录失败: {str(e)}"
+            }
+    
+    def _find_symbol(self, symbol_name: str, directory: str, max_results: int = 20) -> Dict[str, Any]:
+        """查找代码中的符号定义"""
+        try:
+            db = self._get_database()
+            symbols = db.find_symbol(symbol_name)
+            
+            if not symbols:
+                return {
+                    "success": True,
+                    "stdout": f"未找到名为 '{symbol_name}' 的符号",
+                    "symbols": []
+                }
+            
+            # 限制结果数量
+            symbols = symbols[:max_results]
+            
+            # 构建结果
+            result_list = []
+            for symbol in symbols:
+                result_list.append({
+                    "name": symbol.name,
+                    "type": symbol.type.value,
+                    "file": symbol.location.file_path,
+                    "line": symbol.location.start_line,
+                    "column": symbol.location.start_column
+                })
+            
+            # 构建输出文本
+            output_text = f"找到 {len(symbols)} 个名为 '{symbol_name}' 的符号:\n\n"
+            for i, symbol in enumerate(symbols, 1):
+                output_text += (f"{i}. {symbol.type.value}: {symbol.name}\n"
+                               f"   位置: {symbol.location.file_path}:{symbol.location.start_line}:{symbol.location.start_column}\n\n")
+            
+            return {
+                "success": True,
+                "stdout": output_text,
+                "symbols": result_list
+            }
+            
+        except Exception as e:
+            logger.error(f"查找符号失败: {str(e)}")
+            return {
+                "success": False,
+                "stderr": f"查找符号失败: {str(e)}"
+            }
+    
+    def _find_references(self, symbol_name: str, directory: str, max_results: int = 20) -> Dict[str, Any]:
+        """查找代码中符号的引用"""
+        try:
+            db = self._get_database()
+            symbols = db.find_symbol(symbol_name)
+            
+            if not symbols:
+                return {
+                    "success": True,
+                    "stdout": f"未找到名为 '{symbol_name}' 的符号",
+                    "references": []
+                }
+            
+            # 获取第一个匹配符号的所有引用
+            references = db.find_references(symbols[0])
+            
+            # 限制结果数量
+            references = references[:max_results]
+            
+            # 构建结果
+            result_list = []
+            for ref in references:
+                result_list.append({
+                    "file": ref.location.file_path,
+                    "line": ref.location.start_line,
+                    "column": ref.location.start_column
+                })
+            
+            # 构建输出文本
+            output_text = f"找到 {len(references)} 处对 '{symbol_name}' 的引用:\n\n"
+            for i, ref in enumerate(references, 1):
+                output_text += f"{i}. {ref.location.file_path}:{ref.location.start_line}:{ref.location.start_column}\n"
+            
+            return {
+                "success": True,
+                "stdout": output_text,
+                "symbol": {
+                    "name": symbols[0].name,
+                    "type": symbols[0].type.value,
+                    "file": symbols[0].location.file_path,
+                    "line": symbols[0].location.start_line,
+                    "column": symbols[0].location.start_column
+                },
+                "references": result_list
+            }
+            
+        except Exception as e:
+            logger.error(f"查找引用失败: {str(e)}")
+            return {
+                "success": False,
+                "stderr": f"查找引用失败: {str(e)}"
+            }
+    
+    def _find_callers(self, symbol_name: str, directory: str, max_results: int = 20) -> Dict[str, Any]:
+        """查找代码中调用指定函数的位置"""
+        try:
+            db = self._get_database()
+            symbols = db.find_symbol(symbol_name)
+            
+            if not symbols:
+                return {
+                    "success": True,
+                    "stdout": f"未找到名为 '{symbol_name}' 的函数",
+                    "callers": []
+                }
+            
+            # 筛选出函数类型的符号
+            function_symbols = [s for s in symbols if s.type == SymbolType.FUNCTION]
+            if not function_symbols:
+                return {
+                    "success": True,
+                    "stdout": f"'{symbol_name}' 不是一个函数",
+                    "callers": []
+                }
+            
+            # 获取第一个函数符号的所有调用者
+            callers = db.find_callers(function_symbols[0])
+            
+            # 限制结果数量
+            callers = callers[:max_results]
+            
+            # 构建结果
+            result_list = []
+            for caller in callers:
+                result_list.append({
+                    "file": caller.location.file_path,
+                    "line": caller.location.start_line,
+                    "column": caller.location.start_column
+                })
+            
+            # 构建输出文本
+            output_text = f"找到 {len(callers)} 处对函数 '{symbol_name}' 的调用:\n\n"
+            for i, caller in enumerate(callers, 1):
+                output_text += f"{i}. {caller.location.file_path}:{caller.location.start_line}:{caller.location.start_column}\n"
+            
+            return {
+                "success": True,
+                "stdout": output_text,
+                "function": {
+                    "name": function_symbols[0].name,
+                    "file": function_symbols[0].location.file_path,
+                    "line": function_symbols[0].location.start_line,
+                    "column": function_symbols[0].location.start_column
+                },
+                "callers": result_list
+            }
+            
+        except Exception as e:
+            logger.error(f"查找调用者失败: {str(e)}")
+            return {
+                "success": False,
+                "stderr": f"查找调用者失败: {str(e)}"
+            }
+    
+    def execute(self, args: Dict) -> Dict[str, Any]:
+        """执行 Tree-sitter 代码分析
+        
+        参数:
+            args: 包含操作参数的字典
+            
+        返回:
+            Dict[str, Any]: 操作结果
+        """
+        try:
+            action = args.get("action")
+            symbol_name = args.get("symbol_name")
+            directory = args.get("directory", ".")
+            extensions = args.get("extensions", None)
+            max_results = args.get("max_results", 20)
+            
+            # 确保 symbol_name 参数存在
+            if not symbol_name:
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": "缺少必要参数: symbol_name"
+                }
+            
+            # 确保语法目录存在
+            os.makedirs(DEFAULT_GRAMMAR_DIR, exist_ok=True)
+            
+            # 先自动索引目录
+            with yaspin(text="正在索引目录...") as spinner:
+                index_result = self._index_directory(directory, extensions)
+                if not index_result.get("success", False):
+                    spinner.fail("✗")
+                    return index_result
+                spinner.ok("✓")
+            
+            # 根据不同的操作执行相应的函数
+            result = None
+            if action == "find_symbol":
+                result = self._find_symbol(symbol_name, directory, max_results)
+            elif action == "find_references":
+                result = self._find_references(symbol_name, directory, max_results)
+            elif action == "find_callers":
+                result = self._find_callers(symbol_name, directory, max_results)
+            else:
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": f"不支持的操作: {action}"
+                }
+            
+            # 将索引信息添加到结果中
+            if result:
+                if "stdout" in result:
+                    result["stdout"] = f"{index_result.get('index_summary', '')}\n\n{result['stdout']}"
+                else:
+                    result["stdout"] = index_result.get('index_summary', '')
+                    
+            return result
+                
+        except Exception as e:
+            logger.error(f"Tree-sitter 分析失败: {str(e)}")
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": f"Tree-sitter 分析失败: {str(e)}"
+            }
+