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

jarvis/jarvis_tools/function_analyzer.py

@@ -11,7 +11,7 @@ class FunctionAnalyzerTool:
     函数分析工具
     使用agent深入分析函数内部实现，包括子函数调用、全局变量使用等
     """
-    
+
     name = "function_analyzer"
     description = "深入分析函数内部实现，查找子函数调用、全局变量使用等详细信息"
     parameters = {
@@ -60,20 +60,20 @@ class FunctionAnalyzerTool:
         },
         "required": ["function_name"]
     }
-    
+
     def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
         """
         执行函数分析工具
-        
+
         Args:
             args: 包含参数的字典
-            
+
         Returns:
             包含执行结果的字典
         """
         # 存储原始目录
         original_dir = os.getcwd()
-        
+
         try:
             # 解析参数
             function_name = args.get("function_name", "")
@@ -83,7 +83,7 @@ class FunctionAnalyzerTool:
             exclude_dirs = args.get("exclude_dirs", [])
             analysis_depth = args.get("analysis_depth", 1)
             objective = args.get("objective", "")
-            
+
             # 验证参数
             if not function_name:
                 return {
@@ -91,50 +91,46 @@ class FunctionAnalyzerTool:
                     "stdout": "",
                     "stderr": "必须提供函数名称"
                 }
-            
+
             # 创建agent的system prompt
             system_prompt = self._create_system_prompt(
-                function_name, file_path, root_dir, 
+                function_name, file_path, root_dir,
                 file_extensions, exclude_dirs, analysis_depth, objective
             )
-            
+
             # 创建agent的summary prompt
             summary_prompt = self._create_summary_prompt(function_name, analysis_depth)
-            
+
             # 切换到根目录
             os.chdir(root_dir)
-            
+
             # 构建使用的工具
             from jarvis.jarvis_tools.registry import ToolRegistry
             tool_registry = ToolRegistry()
             tool_registry.use_tools(["execute_shell", "read_code"])
-            
+
             # 创建并运行agent
             analyzer_agent = Agent(
                 system_prompt=system_prompt,
                 name=f"FunctionAnalyzer-{function_name}",
                 description=f"分析 '{function_name}' 函数的内部实现",
                 summary_prompt=summary_prompt,
-                platform=PlatformRegistry().get_codegen_platform(),
+                platform=PlatformRegistry().get_normal_platform(),
                 output_handler=[tool_registry],
-                need_summary=True,
-                is_sub_agent=True,
-                use_methodology=False,
-                record_methodology=False,
                 execute_tool_confirm=False,
                 auto_complete=True
             )
-            
+
             # 运行agent并获取结果
             task_input = f"深入分析 '{function_name}' 函数的内部实现，包括子函数调用、全局变量使用等详细信息"
             result = analyzer_agent.run(task_input)
-            
+
             return {
                 "success": True,
                 "stdout": result,
                 "stderr": ""
             }
-                
+
         except Exception as e:
             PrettyOutput.print(str(e), OutputType.ERROR)
             return {
@@ -145,13 +141,13 @@ class FunctionAnalyzerTool:
         finally:
             # 恢复原始目录
             os.chdir(original_dir)
-    
-    def _create_system_prompt(self, function_name: str, file_path: str, root_dir: str, 
+
+    def _create_system_prompt(self, function_name: str, file_path: str, root_dir: str,
                              file_extensions: List[str], exclude_dirs: List[str],
                              analysis_depth: int, objective: str) -> str:
         """
         创建Agent的system prompt
-        
+
         Args:
             function_name: 函数名称
             file_path: 函数所在文件路径
@@ -160,22 +156,39 @@ class FunctionAnalyzerTool:
             exclude_dirs: 排除目录列表
             analysis_depth: 子函数分析深度
             objective: 分析目标
-            
+
         Returns:
             系统提示文本
         """
         file_ext_str = " ".join([f"*{ext}" for ext in file_extensions]) if file_extensions else ""
         exclude_str = " ".join([f"--glob '!{excl}'" for excl in exclude_dirs]) if exclude_dirs else ""
-        
+
         depth_description = "不分析子函数" if analysis_depth == 0 else f"分析 {analysis_depth} 层子函数"
         file_info = f"已知文件路径: {file_path}" if file_path else "需要首先查找函数定义位置"
         objective_text = f"\n\n## 分析目标\n{objective}" if objective else ""
-        
+
         return f"""# 函数实现分析专家
 
 ## 任务描述
 分析函数 `{function_name}` 的实现，专注于分析目标所需的信息，生成有针对性的函数分析报告。{objective_text}
 
+## 工具使用优先级
+1. **首先使用 execute_shell 执行 rg 命令查找函数定义**:
+   - `rg "def\\s+{function_name}\\s*\\(" --type py` 查找Python函数定义
+   - `rg "function\\s+{function_name}\\s*\\(" --type js` 查找JavaScript函数定义
+   - `rg "func\\s+{function_name}\\s*\\(" --type go` 查找Go函数定义
+
+2. **优先使用 read_code 阅读函数实现**:
+   - 找到函数位置后使用read_code阅读完整实现
+   - 对于长函数可分段读取关键部分
+
+3. **使用 rg 搜索子函数调用和使用模式**:
+   - `rg -w "子函数名" --type py` 查找子函数调用
+   - `rg "import|from" 函数所在文件` 查找导入模块
+
+4. **避免使用专用分析工具**:
+   - 只有当rg命令和read_code工具无法满足需求时才考虑
+
 ## 函数信息
 - 函数名称: `{function_name}`
 - {file_info}
@@ -184,33 +197,102 @@ class FunctionAnalyzerTool:
 - 排除目录: {", ".join(exclude_dirs) if exclude_dirs else "无"}
 
 ## 分析策略
-1. 首先理解分析目标，明确需要查找的信息
-2. {"在指定文件中定位函数定义" if file_path else "搜索代码库查找函数定义位置"}
-3. 根据分析目标，确定重点分析的方面
-4. 灵活调整分析深度，关注与目标相关的实现细节
-5. 根据目标需要自行判断是否需要分析子函数
-
-## 执行指令
-- 查找函数定义:
-  ```
-  rg -n "def\\s+{function_name}\\b" {file_ext_str} {exclude_str}
-  ```
-
-- 读取函数实现:
-  ```
-  read_code {{
-    "files": [{{
-      "path": "{file_path or '找到的文件路径'}",
-      "start_line": 函数起始行,
-      "end_line": 函数结束行
-    }}]
-  }}
-  ```
-
-- 查找全局变量:
-  ```
-  rg -n "global\\s+\\w+" --include="{file_path or '找到的文件路径'}"
-  ```
+1. 首先确定项目的主要编程语言和技术栈，以便更准确地分析函数实现
+2. 理解分析目标，明确需要查找的信息
+3. {"在指定文件中定位函数定义" if file_path else "搜索代码库查找函数定义位置"}
+4. 根据分析目标，确定重点分析的方面
+5. 灵活调整分析深度，关注与目标相关的实现细节
+6. 根据目标需要自行判断是否需要分析子函数
+
+## 函数分析工具指南
+
+### execute_shell 搜索命令
+- **查找函数定义**:
+  - `rg "def\\s+{function_name}\\s*\\(" --type py` 查找Python函数定义
+  - `rg "function\\s+{function_name}\\s*\\(" --type js` 查找JavaScript函数定义
+  - `rg "func\\s+{function_name}\\s*\\(" --type go` 查找Go函数定义
+
+- **查找函数调用**:
+  - `rg "\\b{function_name}\\s*\\(" --type py` 查找函数调用
+  - `rg -w "{function_name}" -A 2 -B 2` 查看函数调用上下文
+
+- **分析函数依赖**:
+  - `rg "import|from" 函数所在文件` 查找Python导入语句
+  - `rg "require\\(" 函数所在文件` 查找JavaScript导入语句
+  - `rg "import " 函数所在文件` 查找Go导入语句
+
+- **统计分析**:
+  - `loc 函数所在文件` 获取文件代码统计
+  - `rg -c "if|else|elif" 函数所在文件` 统计条件分支数量
+  - `rg -c "for|while" 函数所在文件` 统计循环数量
+
+### read_code
+- **用途**：读取函数实现和相关代码
+- **典型用法**：
+  - 阅读完整函数实现，包括注释和文档
+  - 阅读关键子函数的实现（根据analysis_depth）
+  - 阅读使用到的关键变量和依赖组件定义
+- **使用策略**：
+  - 首先阅读整个函数以获取完整视图
+  - 识别函数的主要逻辑分支和处理路径
+  - 重点关注错误处理和边界条件检查
+  - 对复杂子函数进行递归分析（不超过指定深度）
+
+### 函数分析模式
+
+1. **逻辑流程分析**：
+   - 识别函数的主要执行路径
+   - 分析条件分支和循环结构
+   - 构建完整的逻辑流程图
+
+2. **参数分析**：
+   - 分析参数类型、默认值和约束条件
+   - 了解参数在函数中的使用方式
+   - 识别关键参数及其影响
+
+3. **依赖与副作用分析**：
+   - 识别函数使用的外部变量和组件
+   - 分析函数对外部状态的修改
+   - 评估函数的纯度和可测试性
+
+4. **异常处理分析**：
+   - 识别可能的异常和错误情况
+   - 分析错误处理和恢复机制
+   - 评估错误处理的完整性和合理性
+
+5. **性能分析**：
+   - 识别潜在的性能瓶颈
+   - 分析循环和递归的效率
+   - 评估算法复杂度
+
+6. **子函数调用分析**：
+   - 识别所有调用的子函数
+   - 分析子函数的作用和调用模式
+   - 在允许的深度内递归分析关键子函数
+
+## 编程范式适应
+
+针对不同的编程范式，函数分析应关注不同方面：
+
+### 过程式/函数式
+- 输入输出关系和纯函数特性
+- 控制流程和数据转换
+- 递归和迭代模式
+
+### 面向对象
+- 方法与类的交互
+- 状态修改和实例变量访问
+- 继承和多态特性
+
+### 事件驱动/回调式
+- 事件注册和触发机制
+- 回调链和异步流程
+- 状态管理和并发控制
+
+### 声明式
+- 规则和约束定义
+- 表达式和模式匹配
+- 执行上下文和环境
 
 ## 输出要求
 - 直接回应分析目标的关键问题
@@ -223,21 +305,22 @@ class FunctionAnalyzerTool:
     def _create_summary_prompt(self, function_name: str, analysis_depth: int) -> str:
         """
         创建Agent的summary prompt
-        
+
         Args:
             function_name: 函数名称
             analysis_depth: 子函数分析深度
-            
+
         Returns:
             总结提示文本
         """
         depth_description = "不包含子函数分析" if analysis_depth == 0 else f"包含 {analysis_depth} 层子函数分析"
-        
+
         return f"""# 函数分析报告: `{function_name}`
 
 ## 报告要求
 生成一份完全以分析目标为导向的函数分析报告，{depth_description}。不要遵循固定的报告模板，而是完全根据分析目标来组织内容：
 
+- 首先简要说明项目的主要编程语言和技术栈
 - 专注回答分析目标提出的问题
 - 只包含与分析目标直接相关的实现发现和洞察
 - 完全跳过与分析目标无关的内容，无需做全面分析
@@ -245,4 +328,4 @@ class FunctionAnalyzerTool:
 - 使用具体的代码片段支持你的观点
 - 以清晰的Markdown格式呈现，简洁明了
 
-在分析中保持灵活性，避免固定思维模式。你的任务不是提供全面的函数概览，而是直接解决分析目标中提出的具体问题。""" 
+在分析中保持灵活性，避免固定思维模式。你的任务不是提供全面的函数概览，而是直接解决分析目标中提出的具体问题。"""

jarvis/jarvis_tools/git_commiter.py

@@ -37,14 +37,14 @@ class GitCommitTool:
     def _extract_commit_message(self, message):
         """Raw extraction preserving all characters"""
         r = re.search(
-            r"(?i)" + ot("COMMIT_MESSAGE") + r"\s*([\s\S]*?)\s*" + ct("COMMIT_MESSAGE"), 
+            r"(?i)" + ot("COMMIT_MESSAGE") + r"\s*([\s\S]*?)\s*" + ct("COMMIT_MESSAGE"),
             message
         )
         if r:
             # 直接返回原始内容，仅去除外围空白
             return shlex.quote(r.group(1).strip())
         return "<<FORMAT VIOLATION>> Invalid commit message structure"
-    
+
     def _get_last_commit_hash(self):
         process = subprocess.Popen(
             ["git", "log", "-1", "--pretty=%H"],
@@ -58,19 +58,19 @@ class GitCommitTool:
         """Execute automatic commit process with support for multi-line messages and special characters"""
         try:
             root_dir = args.get("root_dir", ".")
-            
+
             # Store current directory
             original_dir = os.getcwd()
-            
+
             try:
                 # Change to root_dir
                 os.chdir(root_dir)
-                
+
                 find_git_root()
                 if not has_uncommitted_changes():
                     PrettyOutput.print("没有未提交的更改", OutputType.SUCCESS)
                     return {"success": True, "stdout": "No changes to commit", "stderr": ""}
-                
+
                 with yaspin(text="正在初始化提交流程...", color="cyan") as spinner:
                     # 添加文件
                     spinner.text = "正在添加文件到提交..."
@@ -80,7 +80,7 @@ class GitCommitTool:
                         stderr=subprocess.DEVNULL
                     ).wait()
                     spinner.write("✅ 添加文件到提交")
-                    
+
                     # 获取差异
                     spinner.text = "正在获取代码差异..."
                     process = subprocess.Popen(
@@ -90,7 +90,7 @@ class GitCommitTool:
                     )
                     diff = process.communicate()[0].decode()
                     spinner.write("✅ 获取差异")
-                    
+
                     # 生成提交信息
                     spinner.text = "正在生成提交消息..."
                     prompt = f'''根据以下规则生成提交信息：
@@ -110,11 +110,11 @@ class GitCommitTool:
         # 分析材料
         {diff}
         '''
-                    platform = PlatformRegistry().get_codegen_platform()
+                    platform = PlatformRegistry().get_normal_platform()
                     commit_message = platform.chat_until_success(prompt)
                     commit_message = self._extract_commit_message(commit_message)
                     spinner.write("✅ 生成提交消息")
-                    
+
                     # 执行提交
                     spinner.text = "正在准备提交..."
                     with tempfile.NamedTemporaryFile(mode='w', delete=True) as tmp_file:

jarvis/jarvis_tools/lsp_get_diagnostics.py

@@ -3,7 +3,7 @@ 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"
     # 工具描述
@@ -18,19 +18,19 @@ class LSPGetDiagnosticsTool:
             "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 {
@@ -38,7 +38,7 @@ class LSPGetDiagnosticsTool:
                 "stderr": "Both file_path and language must be provided",
                 "stdout": ""
             }
-            
+
         # 检查文件是否存在
         if not os.path.exists(file_path):
             return {
@@ -46,18 +46,18 @@ class LSPGetDiagnosticsTool:
                 "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 {
@@ -65,7 +65,7 @@ class LSPGetDiagnosticsTool:
                     "stderr": f"No LSP support for language: {language}",
                     "stdout": ""
                 }
-                
+
             try:
                 # 初始化LSP
                 if not lsp.initialize(os.path.abspath(os.getcwd())):
@@ -74,10 +74,10 @@ class LSPGetDiagnosticsTool:
                         "stderr": "LSP initialization failed",
                         "stdout": ""
                     }
-                    
+
                 # 获取诊断信息
                 diagnostics = lsp.get_diagnostics(file_path)
-                
+
                 # 如果没有诊断信息
                 if not diagnostics:
                     return {
@@ -85,31 +85,31 @@ class LSPGetDiagnosticsTool:
                         "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:")
@@ -123,13 +123,13 @@ class LSPGetDiagnosticsTool:
                                 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,