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

jarvis/jarvis_tools/methodology.py

@@ -10,7 +10,7 @@ from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 class MethodologyTool:
     """经验管理工具"""
-    
+
     name = "methodology"
     description = "管理问题解决方法论，支持添加、更新和删除操作"
     parameters = {
@@ -33,12 +33,12 @@ class MethodologyTool:
         },
         "required": ["operation", "problem_type"]
     }
-    
+
     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):
@@ -46,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)
@@ -124,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 {
@@ -132,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

@@ -11,7 +11,7 @@ class ProjectAnalyzerTool:
     项目分析工具
     使用agent分析项目结构、入口点、模块划分等信息（支持所有文件类型）
     """
-    
+
     name = "project_analyzer"
     description = "分析项目结构、入口点、模块划分等信息，提供项目概览（支持所有文件类型）"
     parameters = {
@@ -46,51 +46,51 @@ 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,
@@ -102,17 +102,17 @@ class ProjectAnalyzerTool:
                 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 {
@@ -123,47 +123,46 @@ 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 命令**: 
+1. **优先使用 execute_shell 执行 fd 命令**:
    - `fd -t f -e py` 查找所有Python文件
    - `fd -t d` 列出所有目录
    - `fd README.md` 查找所有README文件
 
-2. **优先使用 execute_shell 执行 rg 命令**: 
+2. **优先使用 execute_shell 执行 rg 命令**:
    - `rg "import" --type py` 搜索导入语句
    - `rg "class|def" --type py` 搜索类和函数定义
    - `rg "TODO|FIXME" --type py` 搜索代码注释
 
-3. **优先使用 execute_shell 执行 loc 命令**: 
+3. **优先使用 execute_shell 执行 loc 命令**:
    - `loc` 统计所有代码行数
-   - `loc --include="*.py"` 统计Python代码行数
 
-4. **辅以 read_code 读取关键文件**: 
+4. **辅以 read_code 读取关键文件**:
    - 读取README.md、配置文件、主要模块
    - 对于较大的文件，可读取关键部分
 
@@ -232,9 +231,6 @@ class ProjectAnalyzerTool:
 
 ### 代码统计分析
 - `loc` 获取项目总体代码统计
-- `loc --include="*.py"` 统计Python代码量
-- `loc --include="*.js" --include="*.jsx" --include="*.ts" --include="*.tsx"` 统计JavaScript/TypeScript代码量
-- `loc --exclude="test"` 排除测试代码后的统计
 
 ### 依赖分析
 - `read_code requirements.txt` 读取Python依赖
@@ -280,16 +276,16 @@ class ProjectAnalyzerTool:
     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}
 
 ## 报告要求
@@ -305,4 +301,4 @@ class ProjectAnalyzerTool:
 - 根据分析目标灵活组织报告结构，不必包含所有传统的项目分析章节
 - 以清晰的Markdown格式呈现，简洁明了
 
-在分析中保持灵活性，避免固定思维模式。你的任务不是提供全面的项目概览，而是直接解决分析目标中提出的具体问题。""" 
+在分析中保持灵活性，避免固定思维模式。你的任务不是提供全面的项目概览，而是直接解决分析目标中提出的具体问题。"""

jarvis/jarvis_tools/rag.py

@@ -32,10 +32,10 @@ class RAGTool:
 
     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
         """
@@ -45,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: 布尔值，表示操作是否成功
@@ -64,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 {
@@ -72,7 +72,7 @@ class RAGTool:
                     "stdout": "",
                     "stderr": f"Directory does not exist: {dir_path}"
                 }
-                
+
             # 检查路径是否为目录
             if not os.path.isdir(dir_path):
                 return {
@@ -80,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 {
@@ -100,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)
@@ -120,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:

jarvis/jarvis_tools/read_code.py

@@ -1,8 +1,10 @@
 from typing import Dict, Any
 import os
 
+from pkg_resources import add_activation_listener
 from yaspin import yaspin
 
+from jarvis.jarvis_utils.globals import add_read_file_record
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 class ReadCodeTool:
@@ -30,17 +32,18 @@ class ReadCodeTool:
 
     def _handle_single_file(self, filepath: str, start_line: int = 1, end_line: int = -1) -> Dict[str, Any]:
         """处理单个文件的读取操作
-        
+
         Args:
             filepath (str): 文件路径
             start_line (int): 起始行号，默认为1
             end_line (int): 结束行号，默认为-1表示文件末尾
-            
+
         Returns:
             Dict[str, Any]: 包含成功状态、输出内容和错误信息的字典
         """
         try:
             abs_path = os.path.abspath(filepath)
+            add_read_file_record(abs_path)
             with yaspin(text=f"正在读取文件: {abs_path}...", color="cyan") as spinner:
                 # 文件存在性检查
                 if not os.path.exists(abs_path):
@@ -49,7 +52,7 @@ class ReadCodeTool:
                         "stdout": "",
                         "stderr": f"文件不存在: {abs_path}"
                     }
-                
+
                 # 文件大小限制检查（10MB）
                 if os.path.getsize(abs_path) > 10 * 1024 * 1024:
                     return {
@@ -57,21 +60,21 @@ class ReadCodeTool:
                         "stdout": "",
                         "stderr": "文件过大 (>10MB)"
                     }
-                
+
                 # 读取文件内容
                 with open(abs_path, 'r', encoding='utf-8', errors="ignore") as f:
                     lines = f.readlines()
-                
+
                 total_lines = len(lines)
-                
+
                 # 处理特殊值-1表示文件末尾
                 if end_line == -1:
                     end_line = total_lines
                 else:
                     end_line = max(1, min(end_line, total_lines)) if end_line >= 0 else total_lines + end_line + 1
-                
+
                 start_line = max(1, min(start_line, total_lines)) if start_line >= 0 else total_lines + start_line + 1
-                
+
                 if start_line > end_line:
                     spinner.fail("❌")
                     return {
@@ -79,20 +82,19 @@ class ReadCodeTool:
                         "stdout": "",
                         "stderr": f"无效的行范围 [{start_line}-{end_line}] (总行数: {total_lines})"
                     }
-                
+
                 # 添加行号并构建输出内容
                 selected_lines = lines[start_line-1:end_line]
                 numbered_content = "".join(
-                    [f"{i:4d}:{line}" 
+                    [f"{i:4d}:{line}"
                      for i, line in enumerate(selected_lines, start=start_line)]
                 )
-                
+
                 # 构建输出格式
                 output = (
                     f"\n🔍 文件: {abs_path}\n"
                     f"📄 原始行号: {start_line}-{end_line} (共{total_lines}行) \n\n"
-                    f"{numbered_content}\n"
-                    f"{'='*80}\n"
+                    f"{numbered_content}\n\n"
                 )
                 spinner.text = f"文件读取完成: {abs_path}"
                 spinner.ok("✅")
@@ -104,7 +106,7 @@ class ReadCodeTool:
                     "stdout": output,
                     "stderr": ""
                 }
-                
+
         except Exception as e:
             PrettyOutput.print(str(e), OutputType.ERROR)
             return {
@@ -115,10 +117,10 @@ class ReadCodeTool:
 
     def execute(self, args: Dict) -> Dict[str, Any]:
         """执行代码读取操作
-        
+
         Args:
             args (Dict): 包含文件列表的参数字典
-            
+
         Returns:
             Dict[str, Any]: 包含成功状态、输出内容和错误信息的字典
         """
@@ -129,32 +131,32 @@ class ReadCodeTool:
                     "stdout": "",
                     "stderr": "参数中必须包含文件列表"
                 }
-            
+
             all_outputs = []
             overall_success = True
-            
+
             for file_info in args["files"]:
                 if not isinstance(file_info, dict) or "path" not in file_info:
                     continue
-                
+
                 result = self._handle_single_file(
                     file_info["path"].strip(),
                     file_info.get("start_line", 1),
                     file_info.get("end_line", -1)
                 )
-                
+
                 if result["success"]:
                     all_outputs.append(result["stdout"])
                 else:
                     all_outputs.append(f"❌ {file_info['path']}: {result['stderr']}")
                     overall_success = False
-                
+
             return {
                 "success": overall_success,
                 "stdout": "\n".join(all_outputs),
                 "stderr": ""
             }
-            
+
         except Exception as e:
             PrettyOutput.print(str(e), OutputType.ERROR)
             return {