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

jarvis/jarvis_smart_shell/main.py

@@ -33,10 +33,10 @@ def execute_command(command: str) -> None:
 
 def process_request(request: str) -> Optional[str]:
     """Process user request and return corresponding shell command
-    
+
     Args:
         request: User's natural language request
-        
+
     Returns:
         Optional[str]: Corresponding shell command, return None if processing fails
     """
@@ -46,7 +46,7 @@ def process_request(request: str) -> Optional[str]:
 
         shell = get_shell_name()
         current_path = os.getcwd()
-        
+
         # Set system prompt
         system_message = """
 # 🤖 Role Definition
@@ -96,18 +96,18 @@ Output: find . -name "*.py"
 
         prefix = f"Current path: {current_path}\n"
         prefix += f"Current shell: {shell}\n"
-        
+
         with yaspin(text="正在生成命令...", color="cyan") as spinner:
             result = model.chat_until_success(prefix + request)
             spinner.ok("✅ 命令生成成功")
-        
+
         # 提取命令
         if result and isinstance(result, str):
             command = result.strip()
             return command
-        
+
         return None
-        
+
     except Exception as e:
         PrettyOutput.print(f"处理请求失败: {str(e)}", OutputType.WARNING)
         return None
@@ -124,25 +124,25 @@ Example:
   %(prog)s "Compress all jpg images"
   %(prog)s "Find documents modified in the last week"
 """)
-    
+
     # 修改为可选参数，添加从stdin读取的支持
     parser.add_argument(
         "request",
         nargs='?',  # 设置为可选参数
         help="描述您想要执行的操作（用自然语言描述），如果未提供则从标准输入读取"
     )
-    
+
     # 解析参数
     args = parser.parse_args()
-    
+
     # 添加标准输入处理
     if not args.request:
         # 检查是否在交互式终端中运行
         args.request = get_multiline_input(tip="请输入您要执行的功能：")
-    
+
     # 处理请求
     command = process_request(args.request)
-    
+
     # 输出结果
     if command:
         execute_command(command)  # 显示并执行命令

jarvis/jarvis_tools/ask_codebase.py

@@ -1,24 +1,21 @@
 from typing import Dict, Any
 import os
-import pathlib
 
-from colorama import init
 
 from jarvis.jarvis_agent import Agent
 from jarvis.jarvis_platform.registry import PlatformRegistry
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.git_utils import find_git_root
-from jarvis.jarvis_utils.config import dont_use_local_model
 from jarvis.jarvis_utils.utils import init_env
 
 class AskCodebaseTool:
     """用于智能代码库查询和分析的工具
-    
+
     适用场景：
-    - 查询特定功能所在的文件位置
-    - 了解单个功能点的实现原理
-    - 查找特定API或接口的用法
-    
+    - 查询特定功能所在的文件位置（支持所有文件类型）
+    - 了解单个功能点的实现原理（支持所有文件类型）
+    - 查找特定API或接口的用法（支持所有文件类型）
+
     不适用场景：
     - 跨越多文件的大范围分析
     - 复杂系统架构的全面评估
@@ -43,26 +40,25 @@ class AskCodebaseTool:
         "required": ["question"]
     }
 
-    @staticmethod
-    def check() -> bool:
-        return not dont_use_local_model()
+    def __init__(self, auto_complete: bool = True):
+        self.auto_complete = auto_complete
 
     def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
         """Execute codebase analysis using an Agent with execute_shell and rag tools
-        
+
         Args:
             args: Dictionary containing:
                 - question: The question to answer, preferably about locating functionality
                   or understanding implementation details of a specific feature
                 - top_k: Optional number of files to analyze
                 - root_dir: Optional root directory of the codebase
-                
+
         Returns:
             Dict containing:
                 - success: Boolean indicating success
                 - stdout: Analysis result
                 - stderr: Error message if any
-                
+
         Note:
             This tool works best for focused questions about specific features or implementations.
             It is not designed for comprehensive multi-file analysis or complex architectural questions.
@@ -70,48 +66,44 @@ class AskCodebaseTool:
         try:
             question = args["question"]
             root_dir = args.get("root_dir", ".")
-            
+
             # Store current directory
             original_dir = os.getcwd()
-            
+
             try:
                 # Change to root_dir
                 os.chdir(root_dir)
-                
+
                 # Get git root directory
                 git_root = find_git_root() or os.getcwd()
-                
+
                 # Create system prompt for the Agent
                 system_prompt = self._create_system_prompt(question, git_root)
-                
+
                 # Create summary prompt for the Agent
                 summary_prompt = self._create_summary_prompt(question)
-                
+
                 # Create tools registry
                 from jarvis.jarvis_tools.registry import ToolRegistry
                 tool_registry = ToolRegistry()
                 tool_registry.use_tools(["execute_shell", "read_code", "rag"])
-                
+
                 # Create and run Agent
                 analyzer_agent = Agent(
                     system_prompt=system_prompt,
                     name=f"CodebaseAnalyzer",
                     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
+                    auto_complete=self.auto_complete
                 )
-                
+
                 # Run agent and get result
                 task_input = f"回答关于代码库的问题: {question}"
                 result = analyzer_agent.run(task_input)
-                
+
                 return {
                     "success": True,
                     "stdout": result,
@@ -128,14 +120,14 @@ class AskCodebaseTool:
                 "stdout": "",
                 "stderr": error_msg
             }
-            
+
     def _create_system_prompt(self, question: str, git_root: str) -> str:
         """创建Agent的system prompt
-        
+
         Args:
             question: 用户问题
             git_root: Git仓库根目录
-            
+
         Returns:
             系统提示文本
         """
@@ -149,70 +141,75 @@ class AskCodebaseTool:
 - 代码库根目录: {git_root}
 
 ## 工具使用优先级
-1. **优先使用 execute_shell**: 首先使用shell命令查找和分析相关文件
-2. **优先使用 read_code**: 找到相关文件后优先使用read_code读取文件内容
-3. **谨慎使用 rag**: 仅在shell命令和直接文件读取无法解决问题时作为辅助手段
+1. **绝对优先使用 execute_shell**:
+   - 使用 fd 查找文件: `fd -t f -e py` 查找Python文件等
+   - 使用 rg 搜索代码: `rg "pattern" --type py` 在Python文件中搜索等
+   - 使用 loc 统计代码: `loc"` 统计代码量
+
+2. **优先使用 read_code**:
+   - 找到相关文件后优先使用read_code读取文件内容
+   - 对大文件使用行范围参数读取指定区域
+
+3. **避免使用 rag**:
+   - 仅在fd、rg和read_code无法解决问题时作为最后手段
+   - 使用rag前必须先尝试使用shell命令解决问题
 
 ## 分析策略
 1. 首先理解问题，确定需要查找的关键信息和代码组件
-2. 使用shell命令(execute_shell)搜索和查找可能相关的文件
-3. 使用read_code工具直接读取和分析相关文件内容
-4. 只有在必要时才使用RAG工具作为辅助手段
-5. 根据文件内容提供具体、准确的回答
+2. 使用fd命令查找可能相关的文件
+3. 使用rg命令搜索关键词和代码模式
+4. 使用read_code工具直接读取和分析相关文件内容
+5. 只有在fd、rg和read_code都无法解决问题时才考虑使用RAG工具
+6. 根据文件内容提供具体、准确的回答
+7. 确保分析的完整性，收集充分的信息后再得出结论
+8. 优先查阅README文件、文档目录和项目文档
 
 ## 分析步骤
-1. **探索代码库结构**:
-   - 使用shell命令了解目录结构，找出可能包含相关功能的位置
-   - 识别主要模块和组件
-
-2. **定位相关文件**:
-   - 优先使用grep、find等shell命令查找关键词
-   - 使用文件名、关键词搜索找到潜在相关文件
-
-3. **深入分析代码**:
+1. **确定项目的编程语言**:
+   - 使用loc命令: `loc` 统计各类文件数量
+   - 查看构建文件和配置文件
+   - 了解项目使用的框架和主要依赖
+
+2. **探索代码库结构**:
+   - 使用 `fd -t d` 了解目录结构
+   - 使用 `fd README.md` 查找README文件
+   - 使用 `fd -e md -g "doc*"` 查找文档文件
+
+3. **定位相关文件**:
+   - 使用fd和rg命令查找关键词
+   - 示例: `rg -w "登录|login" --type py` 查找登录相关代码
+   - 示例: `fd -e py -g "*auth*"` 查找认证相关文件
+
+4. **深入分析代码**:
    - 使用read_code工具直接读取文件内容
    - 分析关键文件的实现细节
-   - 识别功能的实现方式和关键逻辑
+   - 使用rg识别功能的实现方式和关键逻辑
 
-4. **回答问题**:
+5. **回答问题**:
    - 提供基于直接分析代码的具体回答
    - 引用具体文件和代码片段作为依据
 
 ## 关于RAG工具使用
-- RAG工具应作为最后选择，仅在shell命令和直接文件读取无法解决问题时使用
-- RAG工具返回的信息可能存在偏差或不准确之处
+- RAG工具应作为最后选择，仅在fd、rg和read_code都无法解决问题时使用
 - 必须通过查看实际代码文件验证RAG返回的每条重要信息
 - 对于关键发现，始终使用`read_code`工具查看原始文件内容进行求证
 - 如发现RAG结果与实际代码不符，以实际代码为准
 
-## 探索命令示例
-```bash
-# 查看目录结构
-find . -type d -not -path "*/\\.*" | sort
-
-# 搜索与问题相关的文件
-find . -type f -name "*.py" -o -name "*.js" | xargs grep -l "关键词"
-grep -r "关键词" --include="*.py" .
-
-# 查看文件内容
-cat 文件路径
-```
-
-
 ## 输出要求
 - 提供准确、具体的回答，避免模糊不清的描述
 - 引用具体文件路径和代码片段作为依据
 - 如果无法找到答案，明确说明并提供原因
 - 组织信息的逻辑清晰，便于理解
 - 对复杂概念提供简明解释
+- 确保全面收集相关信息后再形成结论
 - 明确区分已验证的信息和待验证的信息"""
 
     def _create_summary_prompt(self, question: str) -> str:
         """创建Agent的summary prompt
-        
+
         Args:
             question: 用户问题
-            
+
         Returns:
             总结提示文本
         """
@@ -225,32 +222,42 @@ cat 文件路径
 
 报告应包含:
 
-1. **问题回答**:
+1. **项目基本信息**:
+   - 项目的主要编程语言和技术栈
+   - 项目的主要框架和依赖
+   - 项目的基本结构
+
+2. **问题回答**:
    - 直接、具体地回答问题
    - 基于代码库中的实际代码
    - 避免模糊或推测性的回答
 
-2. **核心发现**:
+3. **核心发现**:
    - 相关文件和代码位置
    - 关键实现细节
    - 功能运作机制
 
-3. **证据引用**:
+4. **证据引用**:
    - 引用具体文件路径
    - 包含关键代码片段
    - 解释代码如何支持你的回答
 
-4. **局限性**(如有):
+5. **局限性**(如有):
    - 指出分析的任何局限
    - 说明任何无法确定的信息
 
+6. **分析完整性**:
+   - 确保在得出结论前已全面收集和分析相关信息
+   - 避免基于部分信息形成不完整或偏颇的判断
+   - 明确标识哪些是已确认的结论，哪些可能需要进一步验证
+
 使用清晰的Markdown格式，重点突出对问题的回答和支持证据。"""
 
 
 def main():
     """
     命令行入口点，允许将ask_codebase作为独立脚本运行
-    
+
     用法示例:
     ```
     python -m jarvis.jarvis_tools.ask_codebase "登录功能在哪个文件实现？" --root_dir /path/to/codebase
@@ -260,22 +267,22 @@ def main():
     import sys
 
     init_env()
-    
+
     # 创建命令行参数解析器
     parser = argparse.ArgumentParser(description="智能代码库查询工具")
     parser.add_argument("question", help="关于代码库的问题")
     parser.add_argument("--root_dir", "-d", default=".", help="代码库根目录路径")
-    
+
     # 解析命令行参数
     args = parser.parse_args()
-    
+
     # 创建并执行工具
-    tool = AskCodebaseTool()
+    tool = AskCodebaseTool(auto_complete=False)
     result = tool.execute({
         "question": args.question,
         "root_dir": args.root_dir
     })
-    
+
     # 输出结果
     if result["success"]:
         PrettyOutput.print(result["stdout"], OutputType.SUCCESS)

jarvis/jarvis_tools/ask_user.py

@@ -16,35 +16,35 @@ class AskUserTool:
         },
         "required": ["question"]
     }
-        
+
 
     def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
         """Execute the operation of asking the user
-        
+
         Args:
             args: A dictionary containing the question
-            
+
         Returns:
             Dict: A dictionary containing the user's response
         """
         try:
             question = args["question"]
-            
+
             # Display the question
             PrettyOutput.print(f"问题: {question}", OutputType.SYSTEM)
-            
+
             # Get user input
             user_response = get_multiline_input("请输入您的答案 (输入空行结束)")
-            
+
             return {
                 "success": True,
                 "stdout": user_response,
                 "stderr": ""
             }
-            
+
         except Exception as e:
             return {
                 "success": False,
                 "stdout": "",
                 "stderr": f"Failed to ask user: {str(e)}"
-            } 
+            }

jarvis/jarvis_tools/base.py

@@ -2,11 +2,11 @@ from typing import Dict, Any, Callable
 import json
 class Tool:
     """工具类，用于封装工具的基本信息和执行方法"""
-    
+
     def __init__(self, name: str, description: str, parameters: Dict, func: Callable):
         """
         初始化工具对象
-        
+
         参数:
             name (str): 工具名称
             description (str): 工具描述
@@ -27,10 +27,10 @@ class Tool:
     def execute(self, arguments: Dict) -> Dict[str, Any]:
         """
         执行工具函数
-        
+
         参数:
             arguments (Dict): 工具执行所需的参数
-            
+
         返回:
             Dict[str, Any]: 工具执行结果
         """

jarvis/jarvis_tools/chdir.py

@@ -14,19 +14,19 @@ class ChdirTool:
         },
         "required": ["path"]
     }
-    
+
     def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
         """执行目录切换操作，并提供全面的错误处理。
-        
+
         参数:
             args: 包含 'path' 键的字典，目标目录路径
-            
+
         返回:
             字典，包含以下内容：
                 - success: 布尔值，表示操作状态
                 - stdout: 成功消息或空字符串
                 - stderr: 错误消息或空字符串
-                
+
         异常处理:
             处理并返回适当的错误消息：
                 - 不存在的路径
@@ -39,7 +39,7 @@ class ChdirTool:
             # 规范化并展开输入路径（处理 ~ 和相对路径）
             path = os.path.expanduser(args["path"].strip())
             path = os.path.abspath(path)
-            
+
             # 验证目标路径是否存在
             if not os.path.exists(path):
                 return {
@@ -47,7 +47,7 @@ class ChdirTool:
                     "stdout": "",
                     "stderr": f"目录不存在: {path}"
                 }
-                
+
             # 确保路径指向的是目录，而不是文件
             if not os.path.isdir(path):
                 return {
@@ -55,17 +55,17 @@ class ChdirTool:
                     "stdout": "",
                     "stderr": f"路径不是目录: {path}"
                 }
-                
+
             # 获取当前目录并尝试切换到新路径
             old_path = os.getcwd()
             os.chdir(path)
-            
+
             return {
                 "success": True,
                 "stdout": f"成功切换工作目录:\n原目录: {old_path}\n新目录: {path}",
                 "stderr": ""
             }
-            
+
         # 处理用户没有目录访问权限的情况
         except PermissionError:
             return {