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

jarvis/jarvis_tools/find_caller.py

@@ -102,12 +102,8 @@ class FindCallerTool:
                 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
             )
@@ -160,25 +156,93 @@ class FindCallerTool:
 ## 任务描述
 查找所有调用 `{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. **异常使用检测**：
+   - 检查是否存在异常的调用模式
+   - 识别可能存在问题的调用点
+   - 提出优化或修正建议
+
+## 搜索技巧
+- 根据不同编程语言调整函数调用模式的搜索方式
+- 考虑各种编程范式下的不同调用方式（面向对象、函数式等）
+- 考虑函数可能通过变量或回调方式间接调用
+- 检查可能存在的同名函数，确保找到的是目标函数的调用
 
 ## 输出要求
 - 直接回应分析目标的关键问题
@@ -203,6 +267,7 @@ class FindCallerTool:
 ## 报告要求
 生成一份完全以分析目标为导向的函数调用分析报告。不要遵循固定的报告模板，而是完全根据分析目标来组织内容：
 
+- 首先简要说明项目的主要编程语言和技术栈
 - 专注回答分析目标提出的问题
 - 只包含与分析目标直接相关的调用发现和洞察
 - 完全跳过与分析目标无关的内容，无需做全面分析

jarvis/jarvis_tools/find_symbol.py

@@ -102,12 +102,8 @@ class SymbolTool:
                 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
             )
@@ -158,25 +154,112 @@ class SymbolTool:
 ## 任务描述
 查找符号 `{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. **符号关系网络分析**：
+   - 分析与目标符号相关的其他符号
+   - 识别依赖该符号的组件
+   - 了解该符号依赖的其他组件
+
+## 编程范式适应
+
+无论项目使用什么编程语言或范式，符号分析都应考虑以下方面：
+
+### 对象导向程序
+- 类定义、继承关系和实例化
+- 方法重载和覆盖
+- 成员变量和属性访问
+
+### 函数式编程
+- 高阶函数和函数传递
+- 不可变数据结构
+- 闭包和作用域
+
+### 过程式编程
+- 全局和局部变量
+- 函数调用关系
+- 数据流动
+
+### 声明式编程
+- 规则和约束定义
+- 模式匹配
+- 数据转换
 
 ## 输出要求
 - 直接回应分析目标的关键问题
@@ -201,6 +284,7 @@ class SymbolTool:
 ## 报告要求
 生成一份完全以分析目标为导向的符号分析报告。不要遵循固定的报告模板，而是完全根据分析目标来组织内容：
 
+- 首先简要说明项目的主要编程语言和技术栈
 - 专注回答分析目标提出的问题
 - 只包含与分析目标直接相关的符号发现和洞察
 - 完全跳过与分析目标无关的内容，无需做全面分析

jarvis/jarvis_tools/function_analyzer.py

@@ -115,12 +115,8 @@ class FunctionAnalyzerTool:
                 name=f"FunctionAnalyzer-{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
             )
@@ -176,6 +172,23 @@ class FunctionAnalyzerTool:
 ## 任务描述
 分析函数 `{function_name}` 的实现，专注于分析目标所需的信息，生成有针对性的函数分析报告。{objective_text}
 
+## 工具使用优先级
+1. **首先使用 execute_shell 执行 rg 命令查找函数定义**: 
+   - `rg "def\\s+{function_name}\\s*\\(" --type py` 查找Python函数定义
+   - `rg "function\\s+{function_name}\\s*\\(" --type js` 查找JavaScript函数定义
+   - `rg "func\\s+{function_name}\\s*\\(" --type go` 查找Go函数定义
+
+2. **优先使用 read_code 阅读函数实现**: 
+   - 找到函数位置后使用read_code阅读完整实现
+   - 对于长函数可分段读取关键部分
+
+3. **使用 rg 搜索子函数调用和使用模式**:
+   - `rg -w "子函数名" --type py` 查找子函数调用
+   - `rg "import|from" 函数所在文件` 查找导入模块
+
+4. **避免使用专用分析工具**:
+   - 只有当rg命令和read_code工具无法满足需求时才考虑
+
 ## 函数信息
 - 函数名称: `{function_name}`
 - {file_info}
@@ -184,33 +197,102 @@ class FunctionAnalyzerTool:
 - 排除目录: {", ".join(exclude_dirs) if exclude_dirs else "无"}
 
 ## 分析策略
-1. 首先理解分析目标，明确需要查找的信息
-2. {"在指定文件中定位函数定义" if file_path else "搜索代码库查找函数定义位置"}
-3. 根据分析目标，确定重点分析的方面
-4. 灵活调整分析深度，关注与目标相关的实现细节
-5. 根据目标需要自行判断是否需要分析子函数
-
-## 执行指令
-- 查找函数定义:
-  ```
-  rg -n "def\\s+{function_name}\\b" {file_ext_str} {exclude_str}
-  ```
-
-- 读取函数实现:
-  ```
-  read_code {{
-    "files": [{{
-      "path": "{file_path or '找到的文件路径'}",
-      "start_line": 函数起始行,
-      "end_line": 函数结束行
-    }}]
-  }}
-  ```
-
-- 查找全局变量:
-  ```
-  rg -n "global\\s+\\w+" --include="{file_path or '找到的文件路径'}"
-  ```
+1. 首先确定项目的主要编程语言和技术栈，以便更准确地分析函数实现
+2. 理解分析目标，明确需要查找的信息
+3. {"在指定文件中定位函数定义" if file_path else "搜索代码库查找函数定义位置"}
+4. 根据分析目标，确定重点分析的方面
+5. 灵活调整分析深度，关注与目标相关的实现细节
+6. 根据目标需要自行判断是否需要分析子函数
+
+## 函数分析工具指南
+
+### execute_shell 搜索命令
+- **查找函数定义**:
+  - `rg "def\\s+{function_name}\\s*\\(" --type py` 查找Python函数定义
+  - `rg "function\\s+{function_name}\\s*\\(" --type js` 查找JavaScript函数定义
+  - `rg "func\\s+{function_name}\\s*\\(" --type go` 查找Go函数定义
+
+- **查找函数调用**:
+  - `rg "\\b{function_name}\\s*\\(" --type py` 查找函数调用
+  - `rg -w "{function_name}" -A 2 -B 2` 查看函数调用上下文
+
+- **分析函数依赖**:
+  - `rg "import|from" 函数所在文件` 查找Python导入语句
+  - `rg "require\\(" 函数所在文件` 查找JavaScript导入语句
+  - `rg "import " 函数所在文件` 查找Go导入语句
+
+- **统计分析**:
+  - `loc 函数所在文件` 获取文件代码统计
+  - `rg -c "if|else|elif" 函数所在文件` 统计条件分支数量
+  - `rg -c "for|while" 函数所在文件` 统计循环数量
+
+### read_code
+- **用途**：读取函数实现和相关代码
+- **典型用法**：
+  - 阅读完整函数实现，包括注释和文档
+  - 阅读关键子函数的实现（根据analysis_depth）
+  - 阅读使用到的关键变量和依赖组件定义
+- **使用策略**：
+  - 首先阅读整个函数以获取完整视图
+  - 识别函数的主要逻辑分支和处理路径
+  - 重点关注错误处理和边界条件检查
+  - 对复杂子函数进行递归分析（不超过指定深度）
+
+### 函数分析模式
+
+1. **逻辑流程分析**：
+   - 识别函数的主要执行路径
+   - 分析条件分支和循环结构
+   - 构建完整的逻辑流程图
+
+2. **参数分析**：
+   - 分析参数类型、默认值和约束条件
+   - 了解参数在函数中的使用方式
+   - 识别关键参数及其影响
+
+3. **依赖与副作用分析**：
+   - 识别函数使用的外部变量和组件
+   - 分析函数对外部状态的修改
+   - 评估函数的纯度和可测试性
+
+4. **异常处理分析**：
+   - 识别可能的异常和错误情况
+   - 分析错误处理和恢复机制
+   - 评估错误处理的完整性和合理性
+
+5. **性能分析**：
+   - 识别潜在的性能瓶颈
+   - 分析循环和递归的效率
+   - 评估算法复杂度
+
+6. **子函数调用分析**：
+   - 识别所有调用的子函数
+   - 分析子函数的作用和调用模式
+   - 在允许的深度内递归分析关键子函数
+
+## 编程范式适应
+
+针对不同的编程范式，函数分析应关注不同方面：
+
+### 过程式/函数式
+- 输入输出关系和纯函数特性
+- 控制流程和数据转换
+- 递归和迭代模式
+
+### 面向对象
+- 方法与类的交互
+- 状态修改和实例变量访问
+- 继承和多态特性
+
+### 事件驱动/回调式
+- 事件注册和触发机制
+- 回调链和异步流程
+- 状态管理和并发控制
+
+### 声明式
+- 规则和约束定义
+- 表达式和模式匹配
+- 执行上下文和环境
 
 ## 输出要求
 - 直接回应分析目标的关键问题
@@ -238,6 +320,7 @@ class FunctionAnalyzerTool:
 ## 报告要求
 生成一份完全以分析目标为导向的函数分析报告，{depth_description}。不要遵循固定的报告模板，而是完全根据分析目标来组织内容：
 
+- 首先简要说明项目的主要编程语言和技术栈
 - 专注回答分析目标提出的问题
 - 只包含与分析目标直接相关的实现发现和洞察
 - 完全跳过与分析目标无关的内容，无需做全面分析

jarvis/jarvis_tools/git_commiter.py

@@ -110,7 +110,7 @@ class GitCommitTool:
         # 分析材料
         {diff}
         '''
-                    platform = PlatformRegistry().get_codegen_platform()
+                    platform = PlatformRegistry().get_normal_platform()
                     commit_message = platform.chat_until_success(prompt)
                     commit_message = self._extract_commit_message(commit_message)
                     spinner.write("✅ 生成提交消息")

jarvis/jarvis_tools/methodology.py

@@ -4,7 +4,6 @@ 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
 
 
@@ -34,11 +33,6 @@ class MethodologyTool:
         },
         "required": ["operation", "problem_type"]
     }
-
-    @staticmethod
-    def check()->bool:
-        """检查是否启用了方法论功能"""
-        return is_use_methodology()
     
     def __init__(self):
         """初始化经验管理工具"""

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": {
@@ -97,12 +97,8 @@ class ProjectAnalyzerTool:
                 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
             )
@@ -152,42 +148,131 @@ class ProjectAnalyzerTool:
 ## 任务描述
 对项目 `{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` 统计所有代码行数
+   - `loc --include="*.py"` 统计Python代码行数
+
+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. **总结并提供见解**:
+   - 基于分析形成对项目的整体理解
+   - 提供与分析目标直接相关的关键发现
+   - 做出有建设性的评价和建议
+
+## 常用分析命令
+
+### 项目结构分析
+- `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` 查找所有前端和后端文件
+
+### 代码内容分析
+- `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` 查找数据库表定义
+
+### 代码统计分析
+- `loc` 获取项目总体代码统计
+- `loc --include="*.py"` 统计Python代码量
+- `loc --include="*.js" --include="*.jsx" --include="*.ts" --include="*.tsx"` 统计JavaScript/TypeScript代码量
+- `loc --exclude="test"` 排除测试代码后的统计
+
+### 依赖分析
+- `read_code requirements.txt` 读取Python依赖
+- `read_code package.json` 读取Node.js依赖
+- `read_code go.mod` 读取Go依赖
+- `read_code pom.xml` 读取Java Maven依赖
+
+记住：始终将分析目标作为分析过程的指导原则，不必为了完整性而执行与目标无关的步骤。
+
+## 分析框架适应
 
-## 探索命令示例
-```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.*"
-```
+### 前端应用
+- 组件结构和状态管理
+- 路由和页面转换
+- API调用和数据处理
 
-## 分析工具使用
-- 使用`file_analyzer`分析关键文件结构和功能
-- 使用`find_symbol`定位和分析重要符号和函数
-- 使用`function_analyzer`深入理解复杂函数的实现
-- 使用`find_caller`追踪函数调用关系和依赖
+### 数据处理系统
+- 数据流向和转换过程
+- 算法实现和优化方式
+- 并行处理和性能考量
 
-## 分析输出要求
+## 输出要求
 - 直接回应分析目标的关键问题
 - 提供与目标相关的深入洞察
 - 分析内容应直接服务于分析目标
+- 确保全面收集相关信息后再形成结论
 - 避免与目标无关的冗余信息
 - 使用具体代码路径和示例支持分析结论
 - 提供针对分析目标的具体建议和改进方向"""
@@ -210,11 +295,14 @@ find . -name "core.*" -o -name "*core*" -o -name "main.*" -o -name "api.*"
 ## 报告要求
 生成一份完全以分析目标为导向的项目分析报告。不要遵循固定的报告模板，而是完全根据分析目标来组织内容：
 
+- 首先详细说明项目的主要编程语言、技术栈、框架和依赖
 - 专注回答分析目标提出的问题
 - 只包含与分析目标直接相关的发现和洞察
 - 完全跳过与分析目标无关的内容，无需做全面分析
 - 分析深度应与目标的具体需求匹配
 - 使用具体的代码路径和示例支持你的观点
+- 确保在得出结论前已全面收集和分析相关信息，避免基于部分信息形成不完整或偏颇的判断
+- 根据分析目标灵活组织报告结构，不必包含所有传统的项目分析章节
 - 以清晰的Markdown格式呈现，简洁明了
 
 在分析中保持灵活性，避免固定思维模式。你的任务不是提供全面的项目概览，而是直接解决分析目标中提出的具体问题。"""