jarvis-ai-assistant 0.1.130__py3-none-any.whl → 0.1.132__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

@@ -1,5 +1,7 @@
 import os
-import yaml
+import json
+import glob
+import hashlib
 from typing import Dict, Optional, Any
 
 from jarvis.jarvis_utils.config import is_use_methodology
@@ -35,51 +37,68 @@ class MethodologyTool:
 
     @staticmethod
     def check()->bool:
-        """Check if the methodology is enabled"""
+        """检查是否启用了方法论功能"""
         return is_use_methodology()
     
     def __init__(self):
-        """Initialize the experience management tool"""
-        self.methodology_file = os.path.expanduser("~/.jarvis/methodology")
-        self._ensure_file_exists()
+        """初始化经验管理工具"""
+        self.methodology_dir = os.path.expanduser("~/.jarvis/methodologies")
+        self._ensure_dir_exists()
             
-    def _ensure_file_exists(self):
-        """Ensure the methodology file exists"""
-        if not os.path.exists(self.methodology_file):
+    def _ensure_dir_exists(self):
+        """确保方法论目录存在"""
+        if not os.path.exists(self.methodology_dir):
             try:
-                with open(self.methodology_file, 'w', encoding='utf-8') as f:
-                    yaml.safe_dump({}, f, allow_unicode=True)
+                os.makedirs(self.methodology_dir, exist_ok=True)
             except Exception as e:
-                PrettyOutput.print(f"创建方法论文件失败：{str(e)}", OutputType.ERROR)
-                
-    def _load_methodologies(self) -> Dict:
-        """Load all methodologies"""
-        try:
-            with open(self.methodology_file, 'r', encoding='utf-8') as f:
-                return yaml.safe_load(f) or {}
-        except Exception as e:
-            PrettyOutput.print(f"加载方法论失败: {str(e)}", OutputType.ERROR)
-            return {}
+                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 _save_methodologies(self, methodologies: Dict):
-        """Save all methodologies"""
-        try:
-            with open(self.methodology_file, 'w', encoding='utf-8') as f:
-                yaml.safe_dump(methodologies, f, allow_unicode=True)
-        except Exception as e:
-            PrettyOutput.print(f"保存方法论失败: {str(e)}", OutputType.ERROR)
+    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]:
-        """Execute the operation of managing methodologies
+        """执行管理方法论的操作
         
         Args:
-            args: A dictionary containing the operation parameters
-                - operation: The operation type (delete/update/add)
-                - problem_type: The problem type
-                - content: The methodology content (required for update/add)
+            args: 包含操作参数的字典
+                - operation: 操作类型 (delete/update/add)
+                - problem_type: 问题类型
+                - content: 方法论内容 (更新和添加时必填)
             
         Returns:
-            Dict[str, Any]: A dictionary containing the execution result
+            Dict[str, Any]: 包含执行结果的字典
         """
         operation = args.get("operation", "").strip()
         problem_type = args.get("problem_type", "").strip()
@@ -92,16 +111,18 @@ class MethodologyTool:
                 "stderr": "Missing required parameters: operation and problem_type"
             }
             
-        methodologies = self._load_methodologies()
-        
         try:
             if operation == "delete":
-                if problem_type in methodologies:
-                    del methodologies[problem_type]
-                    self._save_methodologies(methodologies)
+                # 获取方法论文件路径
+                file_path = self._get_methodology_file_path(problem_type)
+                
+                # 检查文件是否存在
+                if os.path.exists(file_path):
+                    os.remove(file_path)
                     return {
                         "success": True,
-                        "stdout": f"Deleted methodology for problem type '{problem_type}'"
+                        "stdout": f"Deleted methodology for problem type '{problem_type}'",
+                        "stderr": ""
                     }
                 else:
                     return {
@@ -117,11 +138,21 @@ class MethodologyTool:
                         "stdout": "",
                         "stderr": "Need to provide methodology content"
                     }
-                    
-                methodologies[problem_type] = content
-                self._save_methodologies(methodologies)
                 
-                action = "Update" if problem_type in methodologies else "Add"
+                # 确保目录存在
+                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)
+                
+                action = "Updated" if os.path.exists(file_path) else "Added"
                 return {
                     "success": True,
                     "stdout": f"{action} methodology for problem type '{problem_type}'",
@@ -143,13 +174,23 @@ class MethodologyTool:
             }
             
     def get_methodology(self, problem_type: str) -> Optional[str]:
-        """Get the methodology for a specific problem type
+        """获取特定问题类型的方法论
         
         Args:
-            problem_type: The problem type
+            problem_type: 问题类型
             
         Returns:
-            Optional[str]: The methodology content, or None if it does not exist
+            Optional[str]: 方法论内容，如果不存在则返回 None
         """
-        methodologies = self._load_methodologies()
-        return methodologies.get(problem_type) 
+        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

@@ -0,0 +1,220 @@
+from typing import Dict, Any, List
+import os
+
+from jarvis.jarvis_agent import Agent
+from jarvis.jarvis_platform.registry import PlatformRegistry
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+
+
+class ProjectAnalyzerTool:
+    """
+    项目分析工具
+    使用agent分析项目结构、入口点、模块划分等信息
+    """
+    
+    name = "project_analyzer"
+    description = "分析项目结构、入口点、模块划分等信息，提供项目概览"
+    parameters = {
+        "type": "object",
+        "properties": {
+            "root_dir": {
+                "type": "string",
+                "description": "项目根目录路径（可选）",
+                "default": "."
+            },
+            "focus_dirs": {
+                "type": "array",
+                "items": {
+                    "type": "string"
+                },
+                "description": "要重点分析的目录列表（可选）",
+                "default": []
+            },
+            "exclude_dirs": {
+                "type": "array",
+                "items": {
+                    "type": "string"
+                },
+                "description": "要排除的目录列表（可选）",
+                "default": []
+            },
+            "objective": {
+                "type": "string",
+                "description": "描述本次项目分析的目标和用途，例如'理解项目架构以便进行重构'或'寻找性能瓶颈'",
+                "default": ""
+            }
+        },
+        "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", 
+                "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(),
+                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 {
+                "success": False,
+                "stdout": "",
+                "stderr": f"项目分析失败: {str(e)}"
+            }
+        finally:
+            # 恢复原始目录
+            os.chdir(original_dir)
+    
+    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}
+
+## 分析范围
+- 项目根目录: `{root_dir}`
+- 重点分析: {focus_dirs_str}
+- 排除目录: {exclude_dirs_str}
+
+## 分析策略
+1. 首先理解分析目标，确定你需要寻找什么信息
+2. 灵活采用适合目标的分析方法，不受预设分析框架的限制
+3. 有选择地探索项目，只关注与目标直接相关的部分
+4. 根据目标需要自行判断分析的深度和广度
+
+## 探索命令示例
+```bash
+# 获取项目文件结构
+find . -type f -not -path "*/\\.*" | sort
+
+# 查找可能的入口点
+find . -name "main.*" -o -name "app.*" -o -name "index.*"
+
+# 分析配置文件
+find . -name "*.json" -o -name "*.yaml" -o -name "*.toml" -o -name "*.ini" -o -name "*.conf"
+
+# 查找核心模块
+find . -name "core.*" -o -name "*core*" -o -name "main.*" -o -name "api.*"
+```
+
+## 分析工具使用
+- 使用`file_analyzer`分析关键文件结构和功能
+- 使用`find_symbol`定位和分析重要符号和函数
+- 使用`function_analyzer`深入理解复杂函数的实现
+- 使用`find_caller`追踪函数调用关系和依赖
+
+## 分析输出要求
+- 直接回应分析目标的关键问题
+- 提供与目标相关的深入洞察
+- 分析内容应直接服务于分析目标
+- 避免与目标无关的冗余信息
+- 使用具体代码路径和示例支持分析结论
+- 提供针对分析目标的具体建议和改进方向"""
+
+    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/read_code.py

@@ -7,7 +7,7 @@ from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 class ReadCodeTool:
     name = "read_code"
-    description = "用于读取代码文件并在每行前添加行号的工具"
+    description = "代码阅读与分析工具，用于读取源代码文件并添加行号，针对代码文件优化，提供更好的格式化输出和行号显示，适用于代码分析、审查和理解代码实现的场景"
     parameters = {
         "type": "object",
         "properties": {
@@ -29,6 +29,16 @@ 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)
             with yaspin(text=f"正在读取文件: {abs_path}...", color="cyan") as spinner:
@@ -49,7 +59,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)
@@ -73,7 +83,7 @@ class ReadCodeTool:
                 # 添加行号并构建输出内容
                 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)]
                 )
                 
@@ -86,6 +96,9 @@ class ReadCodeTool:
                 )
                 spinner.text = f"文件读取完成: {abs_path}"
                 spinner.ok("✅")
+
+                PrettyOutput.print(output, OutputType.SUCCESS)
+
                 return {
                     "success": True,
                     "stdout": output,
@@ -101,6 +114,14 @@ class ReadCodeTool:
             }
 
     def execute(self, args: Dict) -> Dict[str, Any]:
+        """执行代码读取操作
+        
+        Args:
+            args (Dict): 包含文件列表的参数字典
+            
+        Returns:
+            Dict[str, Any]: 包含成功状态、输出内容和错误信息的字典
+        """
         try:
             if "files" not in args or not isinstance(args["files"], list):
                 return {