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

jarvis/jarvis_tools/find_caller.py

@@ -11,7 +11,7 @@ class FindCallerTool:
     函数调用者查找工具
     使用agent查找代码库中所有调用指定函数的位置
     """
-    
+
     name = "find_caller"
     description = "查找所有调用指定函数的代码位置"
     parameters = {
@@ -50,20 +50,20 @@ class FindCallerTool:
         },
         "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", "")
@@ -71,7 +71,7 @@ class FindCallerTool:
             file_extensions = args.get("file_extensions", [])
             exclude_dirs = args.get("exclude_dirs", [])
             objective = args.get("objective", "")
-            
+
             # 验证参数
             if not function_name:
                 return {
@@ -79,49 +79,45 @@ class FindCallerTool:
                     "stdout": "",
                     "stderr": "必须提供函数名称"
                 }
-            
+
             # 创建agent的system prompt
             system_prompt = self._create_system_prompt(
                 function_name, root_dir, file_extensions, exclude_dirs, objective
             )
-            
+
             # 创建agent的summary prompt
             summary_prompt = self._create_summary_prompt(function_name)
-            
+
             # 切换到根目录
             os.chdir(root_dir)
-            
+
             # 构建使用的工具
             from jarvis.jarvis_tools.registry import ToolRegistry
             tool_registry = ToolRegistry()
             tool_registry.use_tools(["execute_shell", "read_code"])
-            
+
             # 创建并运行agent
             caller_agent = Agent(
                 system_prompt=system_prompt,
                 name=f"CallerFinder-{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 = caller_agent.run(task_input)
-            
+
             return {
                 "success": True,
                 "stdout": result,
                 "stderr": ""
             }
-                
+
         except Exception as e:
             PrettyOutput.print(str(e), OutputType.ERROR)
             return {
@@ -132,53 +128,121 @@ class FindCallerTool:
         finally:
             # 恢复原始目录
             os.chdir(original_dir)
-    
-    def _create_system_prompt(self, function_name: str, root_dir: str, 
+
+    def _create_system_prompt(self, function_name: str, root_dir: str,
                              file_extensions: List[str], exclude_dirs: List[str],
                              objective: str) -> str:
         """
         创建Agent的system prompt
-        
+
         Args:
             function_name: 函数名称
             root_dir: 代码库根目录
             file_extensions: 文件扩展名列表
             exclude_dirs: 排除目录列表
             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 ""
         objective_text = f"\n\n## 分析目标\n{objective}" if objective else ""
-        
+
         search_pattern = f"\\b{function_name}\\s*\\("
-        
+
         return f"""# 函数调用分析专家
 
 ## 任务描述
 查找所有调用 `{function_name}` 函数的代码位置，专注于分析目标所需的信息，生成有针对性的调用分析报告。{objective_text}
 
+## 工具使用优先级
+1. **优先使用 execute_shell 执行 rg 命令**:
+   - `rg "\\b{function_name}\\s*\\(" --type py` 查找Python文件中的调用
+   - `rg "\\b{function_name}\\s*\\(" --type js` 查找JavaScript文件中的调用
+   - `rg -w "{function_name}" -A 2 -B 2` 查看调用上下文
+
+2. **辅以 read_code**:
+   - 找到调用位置后使用read_code阅读上下文
+   - 读取关键调用者的完整实现
+
+3. **避免使用专用分析工具**:
+   - 只有当rg命令和read_code工具无法满足需求时才考虑
+
 ## 工作环境
 - 工作目录: `{root_dir}`
 - 文件类型: {file_ext_str if file_ext_str else "所有文件"}
 - 排除目录: {", ".join(exclude_dirs) if exclude_dirs else "无"}
 
 ## 分析策略
-1. 首先理解分析目标，明确需要查找的信息类型
-2. 使用适当的搜索模式查找函数调用
-3. 验证搜索结果，确认是对目标函数的真正调用
-4. 分析调用上下文，了解调用的目的和方式
-5. 根据分析目标自行确定需要的分析深度和广度
-
-## 执行指令
-- 使用ripgrep(rg)或grep搜索函数调用:
-  ```
-  rg -n "{search_pattern}" {file_ext_str} {exclude_str}
-  ```
-- 使用`read_code`查看上下文分析调用情况
-- 可能需要先找到函数定义以确认正确的函数签名
+1. 首先确定项目的主要编程语言和技术栈，以便更精确地查找函数调用
+2. 理解分析目标，明确需要查找的信息类型
+3. 使用适当的rg搜索模式查找函数调用
+4. 验证搜索结果，确认是对目标函数的真正调用
+5. 分析调用上下文，了解调用的目的和方式
+6. 根据分析目标自行确定需要的分析深度和广度
+
+## 调用者查找工具指南
+
+### execute_shell 搜索命令
+- **基本搜索**:
+  - `rg "\\b{function_name}\\s*\\(" --type=文件类型`
+  - 示例: `rg "\\b{function_name}\\s*\\(" --type py` 搜索Python文件中的调用
+
+- **查看上下文**:
+  - `rg "\\b{function_name}\\s*\\(" -A 5 -B 5` 显示调用前后5行
+  - `rg "\\b{function_name}\\s*\\(" --context=10` 显示调用前后10行
+
+- **排除目录**:
+  - `rg "\\b{function_name}\\s*\\(" --type py -g '!tests/'` 排除测试目录
+  - `rg "\\b{function_name}\\s*\\(" -g '!node_modules/'` 排除node_modules
+
+- **统计调用**:
+  - `rg -c "\\b{function_name}\\s*\\(" --type py` 统计每个Python文件中的调用次数
+  - `rg "\\b{function_name}\\s*\\(" --count-matches --stats` 显示调用统计信息
+
+### read_code
+- **用途**：读取找到的调用点上下文
+- **典型用法**：
+  - 读取调用函数的整个方法或类
+  - 读取调用点的上下文行（前后5-10行）
+- **使用策略**：
+  - 首先读取足够的上下文以理解调用目的
+  - 对于复杂调用，可能需要读取整个调用函数
+  - 关注调用前的参数准备和调用后的结果处理
+
+### 调用者分析模式
+
+1. **影响范围评估模式**：
+   - 查找所有调用点: `rg -l "\\b{function_name}\\s*\\("`
+   - 按模块/组件分类调用位置
+   - 评估修改函数可能影响的范围和严重性
+
+2. **使用模式分析**：
+   - 分析各调用点的参数传递方式
+   - 识别典型的调用模式和变体
+   - 总结函数的不同使用场景
+
+3. **依赖关系追踪**：
+   - 识别直接调用者
+   - 分析这些调用者自身被谁调用
+   - 构建完整的调用链或调用树
+
+4. **调用频率分析**：
+   - 统计不同模块中的调用频率: `rg -c "\\b{function_name}\\s*\\(" --sort path`
+   - 识别高频调用点和关键路径
+   - 评估函数在系统中的重要性
+
+5. **异常使用检测**：
+   - 检查是否存在异常的调用模式
+   - 识别可能存在问题的调用点
+   - 提出优化或修正建议
+
+## 搜索技巧
+- 根据不同编程语言调整函数调用模式的搜索方式
+- 考虑各种编程范式下的不同调用方式（面向对象、函数式等）
+- 考虑函数可能通过变量或回调方式间接调用
+- 检查可能存在的同名函数，确保找到的是目标函数的调用
 
 ## 输出要求
 - 直接回应分析目标的关键问题
@@ -191,10 +255,10 @@ class FindCallerTool:
     def _create_summary_prompt(self, function_name: str) -> str:
         """
         创建Agent的summary prompt
-        
+
         Args:
             function_name: 函数名称
-            
+
         Returns:
             总结提示文本
         """
@@ -203,6 +267,7 @@ class FindCallerTool:
 ## 报告要求
 生成一份完全以分析目标为导向的函数调用分析报告。不要遵循固定的报告模板，而是完全根据分析目标来组织内容：
 
+- 首先简要说明项目的主要编程语言和技术栈
 - 专注回答分析目标提出的问题
 - 只包含与分析目标直接相关的调用发现和洞察
 - 完全跳过与分析目标无关的内容，无需做全面分析

jarvis/jarvis_tools/find_methodolopy.py

@@ -0,0 +1,65 @@
+from typing import Dict, Any
+from yaspin import yaspin
+
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+from jarvis.jarvis_utils.methodology import load_methodology
+
+class FindMethodologyTool:
+    name = "find_methodology"
+    description = "方法论查找工具，用于在执行过程中查看历史方法论辅助决策"
+    parameters = {
+        "type": "object",
+        "properties": {
+            "query": {
+                "type": "string",
+                "description": "要搜索的查询文本"
+            }
+        },
+        "required": ["query"]
+    }
+
+    def execute(self, args: Dict) -> Dict[str, Any]:
+        """执行方法论查找操作
+
+        Args:
+            args (Dict): 包含查询文本的参数字典
+
+        Returns:
+            Dict[str, Any]: 包含成功状态、输出内容和错误信息的字典
+        """
+        try:
+            if "query" not in args:
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": "参数中必须包含查询文本"
+                }
+
+            with yaspin(text="搜索相关方法论...", color="cyan") as spinner:
+                methodology_prompt = load_methodology(args["query"])
+
+                if methodology_prompt:
+                    spinner.text = "找到相关方法论"
+                    spinner.ok("✅")
+                    PrettyOutput.print(methodology_prompt, OutputType.INFO)
+                    return {
+                        "success": True,
+                        "stdout": methodology_prompt,
+                        "stderr": ""
+                    }
+                else:
+                    spinner.text = "未找到相关方法论"
+                    spinner.fail("❌")
+                    return {
+                        "success": True,
+                        "stdout": "未找到相关的方法论",
+                        "stderr": ""
+                    }
+
+        except Exception as e:
+            PrettyOutput.print(str(e), OutputType.ERROR)
+            return {
+                "success": False,
+                "stdout": "",
+                "stderr": f"方法论查找失败: {str(e)}"
+            }

jarvis/jarvis_tools/find_symbol.py

@@ -11,7 +11,7 @@ class SymbolTool:
     符号查找工具
     使用agent查找代码库中的符号引用、定义和声明位置
     """
-    
+
     name = "find_symbol"
     description = "查找代码符号的引用、定义和声明位置"
     parameters = {
@@ -50,20 +50,20 @@ class SymbolTool:
         },
         "required": ["symbol"]
     }
-    
+
     def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
         """
         执行符号查找工具
-        
+
         Args:
             args: 包含参数的字典
-            
+
         Returns:
             包含执行结果的字典
         """
         # 存储原始目录
         original_dir = os.getcwd()
-        
+
         try:
             # 解析参数
             symbol = args.get("symbol", "")
@@ -71,7 +71,7 @@ class SymbolTool:
             file_extensions = args.get("file_extensions", [])
             exclude_dirs = args.get("exclude_dirs", [])
             objective = args.get("objective", "")
-            
+
             # 验证参数
             if not symbol:
                 return {
@@ -79,49 +79,45 @@ class SymbolTool:
                     "stdout": "",
                     "stderr": "必须提供符号名称"
                 }
-            
+
             # 创建agent的system prompt
             system_prompt = self._create_system_prompt(
                 symbol, root_dir, file_extensions, exclude_dirs, objective
             )
-            
+
             # 创建agent的summary prompt
             summary_prompt = self._create_summary_prompt(symbol)
-            
+
             # 切换到根目录
             os.chdir(root_dir)
-            
+
             # 构建使用的工具
             from jarvis.jarvis_tools.registry import ToolRegistry
             tool_registry = ToolRegistry()
             tool_registry.use_tools(["execute_shell", "read_code"])
-            
+
             # 创建并运行agent
             symbol_agent = Agent(
                 system_prompt=system_prompt,
                 name=f"SymbolFinder-{symbol}",
                 description=f"查找符号 '{symbol}' 的引用和定义位置",
                 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"查找符号 '{symbol}' 在代码库中的引用、定义和声明位置"
             result = symbol_agent.run(task_input)
-            
+
             return {
                 "success": True,
                 "stdout": result,
                 "stderr": ""
             }
-                
+
         except Exception as e:
             PrettyOutput.print(str(e), OutputType.ERROR)
             return {
@@ -132,51 +128,138 @@ class SymbolTool:
         finally:
             # 恢复原始目录
             os.chdir(original_dir)
-    
-    def _create_system_prompt(self, symbol: str, root_dir: str, 
+
+    def _create_system_prompt(self, symbol: str, root_dir: str,
                              file_extensions: List[str], exclude_dirs: List[str],
                              objective: str) -> str:
         """
         创建Agent的system prompt
-        
+
         Args:
             symbol: 符号名称
             root_dir: 代码库根目录
             file_extensions: 文件扩展名列表
             exclude_dirs: 排除目录列表
             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 ""
         objective_text = f"\n\n## 分析目标\n{objective}" if objective else ""
-        
+
         return f"""# 代码符号分析专家
 
 ## 任务描述
 查找符号 `{symbol}` 在代码库中的定义、声明和引用位置，专注于分析目标所需的信息，生成有针对性的符号分析报告。{objective_text}
 
+## 工具使用优先级
+1. **优先使用 execute_shell 执行 rg 命令**:
+   - `rg -w "{symbol}" --type py` 查找Python文件中的符号
+   - `rg "class\\s+{symbol}|def\\s+{symbol}" --type py` 查找定义
+   - `rg -w "{symbol}" -A 2 -B 2` 查看符号上下文
+
+2. **辅以 read_code**:
+   - 找到符号位置后使用read_code阅读上下文
+   - 读取符号定义和关键引用的完整实现
+
+3. **避免使用专用分析工具**:
+   - 只有当rg命令和read_code工具无法满足需求时才考虑
+
 ## 工作环境
 - 工作目录: `{root_dir}`
 - 文件类型: {file_ext_str if file_ext_str else "所有文件"}
 - 排除目录: {", ".join(exclude_dirs) if exclude_dirs else "无"}
 
 ## 分析策略
-1. 首先理解分析目标，明确需要查找的信息类型
-2. 使用适当的搜索模式查找符号定义和引用
-3. 验证搜索结果，确认是目标符号的真正使用
-4. 分析符号上下文，了解其用途和使用方式
-5. 根据分析目标自行确定需要的分析深度和广度
-
-## 执行指令
-- 使用ripgrep(rg)或grep工具搜索代码库:
-  ```
-  rg -n "def\\s+{symbol}\\b|class\\s+{symbol}\\b|{symbol}\\s*=" {file_ext_str} {exclude_str}
-  rg -n "\\b{symbol}\\b" {file_ext_str} {exclude_str}
-  ```
-- 使用`read_code`查看上下文确认结果
+1. 首先确定项目的主要编程语言和技术栈，以便更精确地查找符号
+2. 理解分析目标，明确需要查找的信息类型
+3. 使用适当的rg搜索模式查找符号定义和引用
+4. 验证搜索结果，确认是目标符号的真正使用
+5. 分析符号上下文，了解其用途和使用方式
+6. 根据分析目标自行确定需要的分析深度和广度
+
+## 符号查找工具指南
+
+### execute_shell 搜索命令
+- **基本搜索**:
+  - `rg -w "{symbol}" --type=文件类型`
+  - 示例: `rg -w "{symbol}" --type py` 搜索Python文件中的符号
+
+- **查找定义**:
+  - `rg "class\\s+{symbol}\\b|def\\s+{symbol}\\b|function\\s+{symbol}\\b" --type py` 查找Python定义
+  - `rg "class\\s+{symbol}\\b|function\\s+{symbol}\\b" --type js` 查找JavaScript定义
+  - `rg "const\\s+{symbol}\\b|let\\s+{symbol}\\b|var\\s+{symbol}\\b" --type js` 查找JavaScript变量声明
+
+- **查看上下文**:
+  - `rg -w "{symbol}" -A 5 -B 5` 显示符号前后5行
+  - `rg -w "{symbol}" --context=10` 显示符号前后10行
+
+- **排除目录**:
+  - `rg -w "{symbol}" --type py -g '!tests/'` 排除测试目录
+  - `rg -w "{symbol}" -g '!node_modules/'` 排除node_modules
+
+- **统计引用**:
+  - `rg -c -w "{symbol}" --type py` 统计每个Python文件中的引用次数
+  - `rg -w "{symbol}" --count-matches --stats` 显示引用统计信息
+
+### read_code
+- **用途**：读取符号定义和使用的上下文
+- **典型用法**：
+  - 读取符号定义所在的文件区域
+  - 读取关键使用位置的上下文
+- **使用策略**：
+  - 首先读取符号的定义以理解其属性和行为
+  - 然后读取典型使用场景的代码
+  - 重点关注频繁使用的模式和关键功能点
+
+### 符号分析模式
+
+1. **定义分析模式**：
+   - 首先找到符号的所有定义位置
+   - 分析定义的类型（类、函数、变量、常量等）
+   - 理解符号的属性、参数、返回值等特性
+   - 查看相关注释和文档字符串
+
+2. **使用模式分析**：
+   - 分类统计不同类型的使用方式
+   - 识别典型的使用模式和上下文
+   - 总结符号的主要用途和功能
+
+3. **影响范围评估**：
+   - 统计符号在不同模块中的使用频率
+   - 分析符号修改可能影响的代码范围
+   - 识别关键依赖点和潜在风险区域
+
+4. **符号关系网络分析**：
+   - 分析与目标符号相关的其他符号
+   - 识别依赖该符号的组件
+   - 了解该符号依赖的其他组件
+
+## 编程范式适应
+
+无论项目使用什么编程语言或范式，符号分析都应考虑以下方面：
+
+### 对象导向程序
+- 类定义、继承关系和实例化
+- 方法重载和覆盖
+- 成员变量和属性访问
+
+### 函数式编程
+- 高阶函数和函数传递
+- 不可变数据结构
+- 闭包和作用域
+
+### 过程式编程
+- 全局和局部变量
+- 函数调用关系
+- 数据流动
+
+### 声明式编程
+- 规则和约束定义
+- 模式匹配
+- 数据转换
 
 ## 输出要求
 - 直接回应分析目标的关键问题
@@ -189,10 +272,10 @@ class SymbolTool:
     def _create_summary_prompt(self, symbol: str) -> str:
         """
         创建Agent的summary prompt
-        
+
         Args:
             symbol: 符号名称
-            
+
         Returns:
             总结提示文本
         """
@@ -201,6 +284,7 @@ class SymbolTool:
 ## 报告要求
 生成一份完全以分析目标为导向的符号分析报告。不要遵循固定的报告模板，而是完全根据分析目标来组织内容：
 
+- 首先简要说明项目的主要编程语言和技术栈
 - 专注回答分析目标提出的问题
 - 只包含与分析目标直接相关的符号发现和洞察
 - 完全跳过与分析目标无关的内容，无需做全面分析