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

jarvis/jarvis_tools/methodology.py

@@ -4,14 +4,13 @@ import glob
 import hashlib
 from typing import Dict, Optional, Any
 
-from jarvis.jarvis_utils.config import is_use_methodology
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 
 
 class MethodologyTool:
     """经验管理工具"""
-    
+
     name = "methodology"
     description = "管理问题解决方法论，支持添加、更新和删除操作"
     parameters = {
@@ -35,16 +34,11 @@ class MethodologyTool:
         "required": ["operation", "problem_type"]
     }
 
-    @staticmethod
-    def check()->bool:
-        """检查是否启用了方法论功能"""
-        return is_use_methodology()
-    
     def __init__(self):
         """初始化经验管理工具"""
         self.methodology_dir = os.path.expanduser("~/.jarvis/methodologies")
         self._ensure_dir_exists()
-            
+
     def _ensure_dir_exists(self):
         """确保方法论目录存在"""
         if not os.path.exists(self.methodology_dir):
@@ -52,70 +46,50 @@ class MethodologyTool:
                 os.makedirs(self.methodology_dir, exist_ok=True)
             except Exception as e:
                 PrettyOutput.print(f"创建方法论目录失败：{str(e)}", OutputType.ERROR)
-    
+
     def _get_methodology_file_path(self, problem_type: str) -> str:
         """
         根据问题类型获取对应的方法论文件路径
-        
+
         参数:
             problem_type: 问题类型
-            
+
         返回:
             str: 方法论文件路径
         """
         # 使用MD5哈希作为文件名，避免文件名中的特殊字符
         safe_filename = hashlib.md5(problem_type.encode('utf-8')).hexdigest()
         return os.path.join(self.methodology_dir, f"{safe_filename}.json")
-                
-    def _load_methodologies(self) -> Dict[str, str]:
-        """加载所有方法论"""
-        all_methodologies = {}
-        
-        if not os.path.exists(self.methodology_dir):
-            return all_methodologies
-        
-        for filepath in glob.glob(os.path.join(self.methodology_dir, "*.json")):
-            try:
-                with open(filepath, "r", encoding="utf-8", errors="ignore") as f:
-                    methodology = json.load(f)
-                    problem_type = methodology.get("problem_type", "")
-                    content = methodology.get("content", "")
-                    if problem_type and content:
-                        all_methodologies[problem_type] = content
-            except Exception as e:
-                filename = os.path.basename(filepath)
-                PrettyOutput.print(f"加载方法论文件 {filename} 失败: {str(e)}", OutputType.WARNING)
-        
-        return all_methodologies
-            
+
+
     def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
         """执行管理方法论的操作
-        
+
         Args:
             args: 包含操作参数的字典
                 - operation: 操作类型 (delete/update/add)
                 - problem_type: 问题类型
                 - content: 方法论内容 (更新和添加时必填)
-            
+
         Returns:
             Dict[str, Any]: 包含执行结果的字典
         """
         operation = args.get("operation", "").strip()
         problem_type = args.get("problem_type", "").strip()
         content = args.get("content", "").strip()
-        
+
         if not operation or not problem_type:
             return {
                 "success": False,
                 "stdout": "",
                 "stderr": "Missing required parameters: operation and problem_type"
             }
-            
+
         try:
             if operation == "delete":
                 # 获取方法论文件路径
                 file_path = self._get_methodology_file_path(problem_type)
-                
+
                 # 检查文件是否存在
                 if os.path.exists(file_path):
                     os.remove(file_path)
@@ -130,7 +104,7 @@ class MethodologyTool:
                         "stdout": "",
                         "stderr": f"Methodology for problem type '{problem_type}' not found"
                     }
-                    
+
             elif operation in ["update", "add"]:
                 if not content:
                     return {
@@ -138,59 +112,40 @@ class MethodologyTool:
                         "stdout": "",
                         "stderr": "Need to provide methodology content"
                     }
-                
+
                 # 确保目录存在
                 self._ensure_dir_exists()
-                
+
                 # 获取方法论文件路径
                 file_path = self._get_methodology_file_path(problem_type)
-                
+
                 # 保存方法论到单独的文件
                 with open(file_path, "w", encoding="utf-8", errors="ignore") as f:
                     json.dump({
                         "problem_type": problem_type,
                         "content": content
                     }, f, ensure_ascii=False, indent=2)
-                
+
+                PrettyOutput.print(f"方法论已保存到 {file_path}", OutputType.INFO)
+
                 action = "Updated" if os.path.exists(file_path) else "Added"
                 return {
                     "success": True,
                     "stdout": f"{action} methodology for problem type '{problem_type}'",
                     "stderr": ""
                 }
-                
+
             else:
                 return {
                     "success": False,
                     "stdout": "",
                     "stderr": f"Unsupported operation type: {operation}"
                 }
-                
+
         except Exception as e:
             return {
                 "success": False,
                 "stdout": "",
                 "stderr": f"Execution failed: {str(e)}"
             }
-            
-    def get_methodology(self, problem_type: str) -> Optional[str]:
-        """获取特定问题类型的方法论
-        
-        Args:
-            problem_type: 问题类型
-            
-        Returns:
-            Optional[str]: 方法论内容，如果不存在则返回 None
-        """
-        file_path = self._get_methodology_file_path(problem_type)
-        
-        if not os.path.exists(file_path):
-            return None
-        
-        try:
-            with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
-                methodology = json.load(f)
-                return methodology.get("content")
-        except Exception as e:
-            PrettyOutput.print(f"读取方法论失败: {str(e)}", OutputType.ERROR)
-            return None 
+

jarvis/jarvis_tools/project_analyzer.py

@@ -9,11 +9,11 @@ from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 class ProjectAnalyzerTool:
     """
     项目分析工具
-    使用agent分析项目结构、入口点、模块划分等信息
+    使用agent分析项目结构、入口点、模块划分等信息（支持所有文件类型）
     """
-    
+
     name = "project_analyzer"
-    description = "分析项目结构、入口点、模块划分等信息，提供项目概览"
+    description = "分析项目结构、入口点、模块划分等信息，提供项目概览（支持所有文件类型）"
     parameters = {
         "type": "object",
         "properties": {
@@ -46,77 +46,73 @@ class ProjectAnalyzerTool:
         },
         "required": []
     }
-    
+
     def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
         """
         执行项目分析工具
-        
+
         Args:
             args: 包含参数的字典
-            
+
         Returns:
             包含执行结果的字典
         """
         # 存储原始目录
         original_dir = os.getcwd()
-        
+
         try:
             # 解析参数
             root_dir = args.get("root_dir", ".")
             focus_dirs = args.get("focus_dirs", [])
             exclude_dirs = args.get("exclude_dirs", [])
             objective = args.get("objective", "")
-            
+
             # 创建agent的system prompt
             system_prompt = self._create_system_prompt(
                 root_dir, focus_dirs, exclude_dirs, objective
             )
-            
+
             # 创建agent的summary prompt
             summary_prompt = self._create_summary_prompt(root_dir, objective)
-            
+
             # 切换到根目录
             os.chdir(root_dir)
-            
+
             # 构建使用的工具
             from jarvis.jarvis_tools.registry import ToolRegistry
             tool_registry = ToolRegistry()
             tool_registry.use_tools([
-                "execute_shell", 
-                "read_code", 
+                "execute_shell",
+                "read_code",
                 "find_symbol",
                 "function_analyzer",
                 "find_caller",
                 "file_analyzer",
                 "ask_codebase"
             ])
-            
+
             # 创建并运行agent
             analyzer_agent = Agent(
                 system_prompt=system_prompt,
                 name=f"ProjectAnalyzer",
                 description=f"分析项目结构、模块划分和关键组件",
                 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"分析项目结构、入口点、模块划分等信息，提供项目概览"
             result = analyzer_agent.run(task_input)
-            
+
             return {
                 "success": True,
                 "stdout": result,
                 "stderr": ""
             }
-                
+
         except Exception as e:
             PrettyOutput.print(str(e), OutputType.ERROR)
             return {
@@ -127,67 +123,152 @@ class ProjectAnalyzerTool:
         finally:
             # 恢复原始目录
             os.chdir(original_dir)
-    
-    def _create_system_prompt(self, root_dir: str, focus_dirs: List[str], 
+
+    def _create_system_prompt(self, root_dir: str, focus_dirs: List[str],
                              exclude_dirs: List[str], objective: str) -> str:
         """
         创建Agent的system prompt
-        
+
         Args:
             root_dir: 项目根目录
             focus_dirs: 重点分析的目录列表
             exclude_dirs: 排除的目录列表
             objective: 分析目标
-            
+
         Returns:
             系统提示文本
         """
         focus_dirs_str = ", ".join(focus_dirs) if focus_dirs else "整个项目"
         exclude_dirs_str = ", ".join(exclude_dirs) if exclude_dirs else "无"
-            
+
         objective_text = f"\n\n## 分析目标\n{objective}" if objective else "\n\n## 分析目标\n全面了解项目结构、模块划分和关键组件"
-        
+
         return f"""# 项目架构分析专家
 
 ## 任务描述
 对项目 `{root_dir}` 进行针对性分析，专注于分析目标所需的内容，生成有针对性、深入且有洞察力的项目分析报告。{objective_text}
 
+## 工具使用优先级
+1. **优先使用 execute_shell 执行 fd 命令**:
+   - `fd -t f -e py` 查找所有Python文件
+   - `fd -t d` 列出所有目录
+   - `fd README.md` 查找所有README文件
+
+2. **优先使用 execute_shell 执行 rg 命令**:
+   - `rg "import" --type py` 搜索导入语句
+   - `rg "class|def" --type py` 搜索类和函数定义
+   - `rg "TODO|FIXME" --type py` 搜索代码注释
+
+3. **优先使用 execute_shell 执行 loc 命令**:
+   - `loc` 统计所有代码行数
+
+4. **辅以 read_code 读取关键文件**:
+   - 读取README.md、配置文件、主要模块
+   - 对于较大的文件，可读取关键部分
+
+5. **避免使用专用分析工具**:
+   - 只有当fd、rg、loc命令和read_code工具无法满足需求时才考虑使用
+
 ## 分析范围
 - 项目根目录: `{root_dir}`
 - 重点分析: {focus_dirs_str}
 - 排除目录: {exclude_dirs_str}
 
 ## 分析策略
-1. 首先理解分析目标，确定你需要寻找什么信息
-2. 灵活采用适合目标的分析方法，不受预设分析框架的限制
-3. 有选择地探索项目，只关注与目标直接相关的部分
-4. 根据目标需要自行判断分析的深度和广度
+1. 在一切分析开始前，先使用loc确定项目的主要编程语言和技术栈
+2. 理解分析目标，确定你需要寻找什么信息
+3. 灵活采用适合目标的分析方法，不受预设分析框架的限制
+4. 有选择地探索项目，只关注与目标直接相关的部分
+5. 根据目标需要自行判断分析的深度和广度
+6. 保证分析的完整性，收集充分的信息后再得出结论
+
+## 分析步骤
+以下步骤应根据具体分析目标灵活应用:
+
+1. **确定项目的编程语言和技术栈**:
+   - 使用 `loc` 统计各类文件数量和分布
+   - 使用 `fd package.json` 或 `fd requirements.txt` 查找依赖配置文件
+   - 使用 `read_code` 读取配置文件，确定使用的主要框架和依赖
+
+2. **梳理项目结构**:
+   - 使用 `fd -t d -d 3` 识别三层以内的目录结构
+   - 使用 `fd README.md` 查找并阅读项目说明文件
+   - 使用 `fd -t f -d 1` 查看根目录下的主要文件
+
+3. **定位核心组件**:
+   - 使用 `fd -t f -e py` 找出所有Python文件(或其他语言文件)
+   - 使用 `rg "class\\s+[A-Z]" --type py` 查找主要类定义
+   - 使用 `rg "def\\s+main|if\\s+__name__\\s*==\\s*['\"]__main__['\"]" --type py` 查找入口点
+
+4. **分析入口点和执行流程**:
+   - 使用 `read_code` 读取入口文件内容
+   - 使用 `rg "import|from" 入口文件路径` 查找导入的模块
+   - 分析初始化和主要执行流程
+
+5. **研究核心实现**:
+   - 深入分析与分析目标相关的关键代码
+   - 使用 `read_code` 读取关键文件内容
+   - 使用 `rg` 搜索特定功能的实现
+
+6. **总结并提供见解**:
+   - 基于分析形成对项目的整体理解
+   - 提供与分析目标直接相关的关键发现
+   - 做出有建设性的评价和建议
 
-## 探索命令示例
-```bash
-# 获取项目文件结构
-find . -type f -not -path "*/\\.*" | sort
+## 常用分析命令
 
-# 查找可能的入口点
-find . -name "main.*" -o -name "app.*" -o -name "index.*"
+### 项目结构分析
+- `fd -t d -d 3` 列出三层以内的目录结构
+- `fd -t f -e py -g "test*" -d 3` 查找前三层目录中的Python测试文件
+- `fd -t f -e py | wc -l` 统计Python文件数量
+- `fd -t f -e py -o -e js -o -e html -o -e css` 查找所有前端和后端文件
 
-# 分析配置文件
-find . -name "*.json" -o -name "*.yaml" -o -name "*.toml" -o -name "*.ini" -o -name "*.conf"
+### 代码内容分析
+- `rg "^\\s*class\\s+[A-Z]" --type py` 查找Python类定义
+- `rg "^\\s*def\\s+" --type py` 查找Python函数定义
+- `rg "import|from\\s+.+\\s+import" --type py` 查找Python导入语句
+- `rg "CREATE TABLE" --type sql` 查找数据库表定义
 
-# 查找核心模块
-find . -name "core.*" -o -name "*core*" -o -name "main.*" -o -name "api.*"
-```
+### 代码统计分析
+- `loc` 获取项目总体代码统计
 
-## 分析工具使用
-- 使用`file_analyzer`分析关键文件结构和功能
-- 使用`find_symbol`定位和分析重要符号和函数
-- 使用`function_analyzer`深入理解复杂函数的实现
-- 使用`find_caller`追踪函数调用关系和依赖
+### 依赖分析
+- `read_code requirements.txt` 读取Python依赖
+- `read_code package.json` 读取Node.js依赖
+- `read_code go.mod` 读取Go依赖
+- `read_code pom.xml` 读取Java Maven依赖
 
-## 分析输出要求
+记住：始终将分析目标作为分析过程的指导原则，不必为了完整性而执行与目标无关的步骤。
+
+## 分析框架适应
+
+根据不同类型的项目架构，应调整分析重点：
+
+### 单体应用
+- 核心业务逻辑和数据流
+- 模块划分和内部依赖
+- 扩展点和插件机制
+
+### 微服务架构
+- 服务边界和接口定义
+- 服务间通信和数据交换
+- 服务发现和配置管理
+
+### 前端应用
+- 组件结构和状态管理
+- 路由和页面转换
+- API调用和数据处理
+
+### 数据处理系统
+- 数据流向和转换过程
+- 算法实现和优化方式
+- 并行处理和性能考量
+
+## 输出要求
 - 直接回应分析目标的关键问题
 - 提供与目标相关的深入洞察
 - 分析内容应直接服务于分析目标
+- 确保全面收集相关信息后再形成结论
 - 避免与目标无关的冗余信息
 - 使用具体代码路径和示例支持分析结论
 - 提供针对分析目标的具体建议和改进方向"""
@@ -195,26 +276,29 @@ find . -name "core.*" -o -name "*core*" -o -name "main.*" -o -name "api.*"
     def _create_summary_prompt(self, root_dir: str, objective: str) -> str:
         """
         创建Agent的summary prompt
-        
+
         Args:
             root_dir: 项目根目录
             objective: 分析目标
-            
+
         Returns:
             总结提示文本
         """
         objective_text = f"\n\n## 具体分析目标\n{objective}" if objective else ""
-        
+
         return f"""# 项目分析报告: `{root_dir}`{objective_text}
 
 ## 报告要求
 生成一份完全以分析目标为导向的项目分析报告。不要遵循固定的报告模板，而是完全根据分析目标来组织内容：
 
+- 首先详细说明项目的主要编程语言、技术栈、框架和依赖
 - 专注回答分析目标提出的问题
 - 只包含与分析目标直接相关的发现和洞察
 - 完全跳过与分析目标无关的内容，无需做全面分析
 - 分析深度应与目标的具体需求匹配
 - 使用具体的代码路径和示例支持你的观点
+- 确保在得出结论前已全面收集和分析相关信息，避免基于部分信息形成不完整或偏颇的判断
+- 根据分析目标灵活组织报告结构，不必包含所有传统的项目分析章节
 - 以清晰的Markdown格式呈现，简洁明了
 
-在分析中保持灵活性，避免固定思维模式。你的任务不是提供全面的项目概览，而是直接解决分析目标中提出的具体问题。""" 
+在分析中保持灵活性，避免固定思维模式。你的任务不是提供全面的项目概览，而是直接解决分析目标中提出的具体问题。"""

jarvis/jarvis_tools/rag.py

@@ -1,7 +1,6 @@
 from typing import Dict, Any
 import os
 from jarvis.jarvis_rag.main import RAGTool as RAGCore
-from jarvis.jarvis_utils.config import dont_use_local_model
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 class RAGTool:
@@ -27,20 +26,16 @@ class RAGTool:
         "required": ["dir", "question"]
     }
 
-    @staticmethod
-    def check() -> bool:
-        return not dont_use_local_model()
-
     def __init__(self):
         """Initialize RAG tool"""
         self.rag_instances = {}  # Cache RAG instances for different directories
 
     def _get_rag_instance(self, dir_path: str) -> RAGCore:
         """Get or create RAG instance
-        
+
         Args:
             dir_path: The absolute path of the document directory
-            
+
         Returns:
             RAGCore: RAG instance
         """
@@ -50,13 +45,13 @@ class RAGTool:
 
     def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
         """执行文档问答
-        
+
         Args:
             args: 包含参数的字典
                 - dir: 文档目录路径
                 - question: 要询问的问题
                 - rebuild_index: 是否重建索引
-                
+
         Returns:
             Dict[str, Any]: 执行结果，包含以下字段：
                 - success: 布尔值，表示操作是否成功
@@ -69,7 +64,7 @@ class RAGTool:
             dir_path = os.path.abspath(dir_path)
             question = args["question"]
             rebuild_index = args.get("rebuild_index", False)
-            
+
             # 检查目录是否存在
             if not os.path.exists(dir_path):
                 return {
@@ -77,7 +72,7 @@ class RAGTool:
                     "stdout": "",
                     "stderr": f"Directory does not exist: {dir_path}"
                 }
-                
+
             # 检查路径是否为目录
             if not os.path.isdir(dir_path):
                 return {
@@ -85,19 +80,19 @@ class RAGTool:
                     "stdout": "",
                     "stderr": f"The path is not a directory: {dir_path}"
                 }
-                
+
             # 获取RAG实例
             rag = self._get_rag_instance(dir_path)
-            
+
             # 如果需要重建索引或索引不存在
             if rebuild_index or not rag.is_index_built():
                 PrettyOutput.print("正在构建文档索引...", OutputType.INFO)
                 rag.build_index(dir_path)
-            
+
             # 执行问答
             PrettyOutput.print(f"问题: {question}", OutputType.INFO)
             response = rag.ask(question)
-            
+
             # 处理未找到相关文档的情况
             if response is None:
                 return {
@@ -105,14 +100,14 @@ class RAGTool:
                     "stdout": "",
                     "stderr": "Failed to get answer, possibly no relevant documents found"
                 }
-                
+
             # 返回成功响应
             return {
                 "success": True,
                 "stdout": response,
                 "stderr": ""
             }
-            
+
         except Exception as e:
             # 处理任何意外错误
             PrettyOutput.print(f"文档问答失败：{str(e)}", OutputType.ERROR)
@@ -125,20 +120,20 @@ class RAGTool:
 def main():
     """Run the tool directly from the command line"""
     import argparse
-    
+
     parser = argparse.ArgumentParser(description='Document question and answer tool')
     parser.add_argument('--dir', required=True, help='Document directory path')
     parser.add_argument('--question', required=True, help='The question to ask')
     parser.add_argument('--rebuild', action='store_true', help='Rebuild index')
     args = parser.parse_args()
-    
+
     tool = RAGTool()
     result = tool.execute({
         "dir": args.dir,
         "question": args.question,
         "rebuild_index": args.rebuild
     })
-    
+
     if result["success"]:
         PrettyOutput.print(f"{result['stdout']}", OutputType.INFO, lang="markdown")
     else: