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

jarvis/jarvis_agent/patch.py

@@ -5,6 +5,7 @@ import os
 from yaspin import yaspin
 
 from jarvis.jarvis_agent.output_handler import OutputHandler
+from jarvis.jarvis_platform.base import BasePlatform
 from jarvis.jarvis_platform.registry import PlatformRegistry
 from jarvis.jarvis_tools.git_commiter import GitCommitTool
 from jarvis.jarvis_tools.file_operation import FileOperationTool
@@ -168,11 +169,15 @@ def apply_patch(output_str: str) -> str:
                     
                     # 增加代码变更分析和错误提示
                     final_ret += "\n\n# 代码变更分析：\n"
-                    final_ret += "1. 请仔细检查以上变更是否引入了潜在错误\n"
+                    final_ret += "1. 请使用静态检查工具（如有）检查以上变更是否引入了潜在错误\n"
                     final_ret += "2. 如果发现代码错误，请立即提出修复方案\n"
                     final_ret += "3. 修复代码错误的优先级高于继续实现功能\n"
-                    final_ret += "4. 常见错误类型：语法错误、逻辑错误、命名错误、路径错误等\n"
-                    final_ret += "5. 确保修改后代码的一致性和完整性\n"
+                    final_ret += "4. 确保修改后代码的一致性和完整性\n"
+                    final_ret += "5. 请确认所有相关点是否已修改完成，包括但不限于：\n"
+                    final_ret += "   - 所有需要修改的文件\n"
+                    final_ret += "   - 所有需要更新的函数\n"
+                    final_ret += "   - 所有需要调整的依赖关系\n"
+                    final_ret += "   - 所有需要同步的文档\n"
                     final_ret += "\n\n"
                     final_ret += "如果没有问题，请继续进行下一步修改，如果所有修改都已经完成，请终止"
                     
@@ -182,20 +187,20 @@ def apply_patch(output_str: str) -> str:
                 final_ret += "❌ 补丁应用被拒绝\n"
                 final_ret += f"# 补丁预览:\n```diff\n{diff}\n```"
         else:
+            commited = False
             final_ret += "❌ 没有要提交的更改\n"
         # 用户确认最终结果
         with spinner.hidden():
+            if commited:
+                return final_ret
             PrettyOutput.print(final_ret, OutputType.USER, lang="markdown")
             if not is_confirm_before_apply_patch() or user_confirm("是否使用此回复？", default=True):
                 return final_ret
             custom_reply = get_multiline_input("请输入自定义回复")
             if not custom_reply.strip():  # 如果自定义回复为空，返回空字符串
                 return ""
-            if not commited:
-                return final_ret + "\n\n" + custom_reply
-            else:
-                return custom_reply
-
+            return final_ret + "\n\n" + custom_reply
+            
 def revert_file(filepath: str):
     """增强版git恢复，处理新文件"""
     import subprocess
@@ -258,7 +263,7 @@ def handle_code_operation(filepath: str, patch_content: str) -> bool:
         retry_count = 5
         while retry_count > 0:
             retry_count -= 1
-            if handle_large_code_operation(filepath, patch_content):
+            if handle_large_code_operation(filepath, patch_content, PlatformRegistry().get_normal_platform() if retry_count > 2 else PlatformRegistry().get_thinking_platform()):
                 return True
         return handle_small_code_operation(filepath, patch_content)
 
@@ -308,7 +313,7 @@ def handle_small_code_operation(filepath: str, patch_content: str) -> bool:
 [合并后的完整代码，包括所有空行和缩进]
 {ct("MERGED_CODE")}
 """
-            model = PlatformRegistry().get_codegen_platform()
+            model = PlatformRegistry().get_normal_platform()
             model.set_suppress_output(True)
             count = 30
             start_line = -1
@@ -365,7 +370,7 @@ def handle_small_code_operation(filepath: str, patch_content: str) -> bool:
             return False
 
 
-def handle_large_code_operation(filepath: str, patch_content: str) -> bool:
+def handle_large_code_operation(filepath: str, patch_content: str, model: BasePlatform) -> bool:
     """处理大型代码文件的补丁操作，使用差异化补丁格式"""
     with yaspin(text=f"正在处理文件 {filepath}...", color="cyan") as spinner:
         try:
@@ -376,7 +381,6 @@ def handle_large_code_operation(filepath: str, patch_content: str) -> bool:
                 spinner.fail("❌")
                 return False
             
-            model = PlatformRegistry().get_codegen_platform()
             model.set_suppress_output(True)
             
             prompt = f"""

jarvis/jarvis_code_agent/code_agent.py

@@ -1,5 +1,8 @@
 import subprocess
 import os
+import argparse
+from token import OP
+from typing import Optional
 
 from yaspin import yaspin
 
@@ -22,7 +25,7 @@ from jarvis.jarvis_utils.utils import init_env, user_confirm
 
 
 class CodeAgent:
-    def __init__(self):
+    def __init__(self, platform : Optional[str] = None, model: Optional[str] = None, need_summary: bool = True):
         self.root_dir = os.getcwd()
         tool_registry = ToolRegistry()
         tool_registry.use_tools(["execute_shell", 
@@ -31,119 +34,162 @@ class CodeAgent:
                                  "ask_user",  
                                  "ask_codebase",
                                  "lsp_get_diagnostics", 
-                                 "lsp_find_references", 
-                                 "lsp_find_definition",
                                  "code_review",  # 代码审查工具
                                  "find_symbol",  # 添加符号查找工具
                                  "find_caller",  # 添加函数调用者查找工具
                                  "function_analyzer",  # 添加函数分析工具
                                  "project_analyzer",  # 添加项目分析工具
-                                 "file_analyzer"  # 添加单文件分析工具
+                                 "file_analyzer",  # 添加单文件分析工具
+                                 "read_code"
                                  ])
         code_system_prompt = """
-# 专业代码工程师
-
-## 身份与职责
-- **角色**：精通代码修改的高级工程师
-- **能力**：代码分析、精准重构和系统化验证
-- **知识**：软件架构、设计模式和编程最佳实践
-
-## 工作原则
-- **准备工作**：在修改任何代码之前，必须已经阅读并充分理解相关代码
-- **分析范围判断**：首先评估当前文件内容是否足够完成修改，避免不必要的项目分析
-- **沟通**：清晰简洁的技术解释，提供决策依据
-- **代码修改**：结构化展示变更及其上下文
-- **问题处理**：遇到模糊请求时提出澄清问题，高风险变更时提出渐进式方法
-- **修改效率**：对于变更不超过50行的代码，应一次性完成修改，避免分段处理
-
-## 任务执行流程
-### 分析阶段
-- **范围确定**：首先判断是否仅需当前文件内容即可完成任务，避免不必要的分析
-- 评估任务复杂度，只在必要时进行全面分析
-- 简单修改可直接进行，无需复杂分析
-- 使用代码分析工具理解依赖关系
-- 识别潜在影响区域
-- 确保在开始修改前，已经完全阅读和理解相关代码文件
-
-### 实施阶段
-- 进行最小范围更改，保持代码完整性
-- 对于不超过50行的代码变更，应一次性完成修改
-- 大型文件分段修改，确保每段修改后代码功能完整
-- 保持一致的代码风格和格式
-- 修改后立即验证，优先修复错误
-
-### 验证阶段
-- 确认已充分理解所修改代码及其上下文
-- 使用诊断工具检查问题
-- 检查相关代码中的意外副作用
-- 确保兼容性和功能正确性
-- 验证修改是否符合原始设计意图和代码结构
-
-### 文档阶段
-- 提供清晰的修改理由和上下文
-- 记录假设和约束条件
-- 准备详细的提交信息
-
-## 工具使用指南
-- **范围决策**：
-  - 先阅读当前文件，判断是否包含足够信息完成任务
-  - 只有在确认需要更多上下文时才扩展分析范围
-  - 明确告知用户当前文件是否足够，避免不必要分析
-
-- **代码阅读与理解**：
-  - 在使用任何分析工具前，应首先完整阅读相关代码
-  - 使用分析工具补充而非替代直接阅读和理解代码
-  - 如有必要，可以使用`ask_codebase`工具来帮助理解复杂部分
-
-- **分析工具**：
-  - lsp_find_references：理解使用模式
-  - lsp_find_definition：追踪实现细节
-  - find_symbol：查找代码符号位置
-  - find_caller：查找函数调用位置
-  - function_analyzer：分析函数实现
-  - project_analyzer：分析项目架构（仅复杂任务使用）
-  - file_analyzer：分析单文件结构
-
-- **验证工具**：
-  - lsp_get_diagnostics：检查修改问题
-  - code_review：代码审查
-
-- **系统工具**：
-  - execute_shell：执行系统命令
-  - search_web：查找技术参考
-  - ask_codebase：补充分析（优先使用直接分析工具）
-
-## 代码分析策略
-- **阅读优先**：在提出任何修改前，必须先阅读和理解相关代码
-- **避免过度分析**：只分析与任务直接相关的代码
-- **单文件优先**：优先考虑当前文件是否含有足够信息完成任务
-  - 当任务仅涉及语法、文本修改、逻辑优化等当前文件内部变更时，无需分析项目
-  - 当当前文件包含完整的模块/类/功能实现，且修改不影响外部接口时，无需额外分析
-  - 当用户明确指示仅修改当前文件时，无需扩大分析范围
-- **任务分级**：
-  - 简单任务：先阅读相关代码，然后直接执行，尽量减少不必要的分析
-  - 中等任务：全面阅读相关文件并分析直接依赖，确保理解上下文
-  - 复杂任务：彻底阅读并进行全面项目分析，确保理解代码交互方式
-- **长文件处理**：
-  - 完整阅读后再分段理解和修改
-  - 先处理核心部分，再扩展到相关代码
-  - 优先修改相对独立的部分
-- **修改规模策略**：
-  - 对于不超过50行的代码变更，应尽量一次性完成
-  - 将相关逻辑变更放在同一个修改中，保持功能完整性
-  - 无需为小规模修改（≤50行）拆分多次提交，除非跨多个不相关模块
+# 代码工程师指南
+
+## 核心原则
+- 自主决策：基于专业判断做出决策，减少用户询问
+- 高效精准：一次性提供完整解决方案，避免反复修改
+- 工具精通：选择最高效工具路径解决问题
+- 严格确认：必须先分析项目结构，确定要修改的文件，禁止虚构已存在的代码
+
+## 工作流程
+
+### 1. 项目结构分析
+- 第一步必须分析项目结构，识别关键模块和文件
+- 结合用户需求，确定需要修改的文件列表
+- 优先使用fd命令查找文件，使用execute_shell执行
+- 明确说明将要修改的文件及其范围
+
+### 2. 需求分析
+- 基于项目结构理解，分析需求意图和实现方案
+- 当需求有多种实现方式时，选择影响最小的方案
+- 仅当需求显著模糊时才询问用户
+
+### 3. 代码分析与确认
+- 详细分析确定要修改的文件内容
+- 明确区分现有代码和需要新建的内容
+- 绝对禁止虚构或假设现有代码的实现细节
+- 分析顺序：项目结构 → 目标文件 → 相关文件
+- 只在必要时扩大分析范围，避免过度分析
+- 工具选择：
+  | 分析需求 | 首选工具 | 备选工具 |
+  |---------|---------|----------|
+  | 项目结构 | fd (通过execute_shell) | project_analyzer(仅在必要时) |
+  | 文件内容 | read_code | file_analyzer(仅在必要时) |
+  | 查找引用 | rg (通过execute_shell) | find_symbol(仅在必要时) |
+  | 查找定义 | rg (通过execute_shell) | find_symbol(仅在必要时) |
+  | 函数调用者 | rg (通过execute_shell) | find_caller(仅在必要时) |
+  | 函数分析 | read_code + rg | function_analyzer(仅在必要时) |
+  | 整体分析 | execute_shell_script | ask_codebase(仅在必要时) |
+  | 代码质量检查 | execute_shell | code_review(仅在必要时) |
+  | 统计代码行数 | loc (通过execute_shell) | - |
+
+### 4. 方案设计
+- 确定最小变更方案，保持代码结构
+- 变更类型处理：
+  - 修改现有文件：必须先确认文件存在及其内容
+  - 创建新文件：可以根据需求创建，但要符合项目结构和风格
+- 变更规模处理：
+  - ≤50行：一次性完成所有修改
+  - 50-200行：按功能模块分组
+  - >200行：按功能拆分，但尽量减少提交次数
+
+### 5. 实施修改
+- 遵循"先读后写"原则，在修改已有代码前，必须已经读取了对应文件
+- 保持代码风格一致性
+- 自动匹配项目现有命名风格
+- 允许创建新文件和结构，但不得假设或虚构现有代码
+
+### 6. 验证
+- 修改后自动验证：
+  1. 优先使用execute_shell运行相关静态检查命令（如pylint、flake8或单元测试）
+  2. 只有在shell命令不足时才使用lsp_get_diagnostics
+  3. 只有在特殊情况下才使用code_review
+- 发现问题自动修复，无需用户指导
+
+## 专用工具简介
+仅在必要时使用以下专用工具：
+
+- **project_analyzer**: 项目整体结构分析，仅在fd命令无法满足需求时使用
+- **file_analyzer**: 单文件深度分析，应优先使用read_code替代
+- **find_caller**: 函数调用者查找，应优先使用rg命令替代
+- **find_symbol**: 符号引用查找，应优先使用rg命令替代
+- **function_analyzer**: 函数实现分析，应优先使用read_code和rg组合替代
+- **ask_codebase**: 代码库整体查询，应优先使用fd、rg和read_code组合替代
+- **code_review**: 代码质量检查，应优先使用语言特定的lint工具替代
+
+## Shell命令优先策略
+
+### 优先使用的Shell命令
+- **项目结构分析**：
+  - `fd -t f -e py` 查找所有Python文件
+  - `fd -t f -e js -e ts` 查找所有JavaScript/TypeScript文件
+  - `fd -t d` 列出所有目录
+  - `fd -t f -e java -e kt` 查找所有Java/Kotlin文件
+  - `fd -t f -e go` 查找所有Go文件
+  - `fd -t f -e rs` 查找所有Rust文件
+  - `fd -t f -e c -e cpp -e h -e hpp` 查找所有C/C++文件
+  
+- **代码内容搜索**：
+  - `rg "pattern" --type py` 在Python文件中搜索
+  - `rg "pattern" --type js` 在JavaScript文件中搜索
+  - `rg "pattern" --type java` 在Java文件中搜索
+  - `rg "pattern" --type c` 在C文件中搜索
+  - `rg "class ClassName"` 查找类定义
+  - `rg "func|function|def" -g "*.py" -g "*.js" -g "*.go" -g "*.rs"` 查找函数定义
+  - `rg -w "word"` 精确匹配单词
+
+- **代码统计分析**：
+  - `loc <file_path>` 统计单个文件
+  - `loc --include="*.py"` 统计所有Python文件
+  - `loc --include="*.js" --include="*.ts"` 统计所有JavaScript/TypeScript文件
+  - `loc --exclude="test"` 排除测试文件
+  - `loc --sort=code` 按代码量排序
+
+- **代码质量检查**：
+  - Python: `pylint <file_path>`, `flake8 <file_path>`
+  - JavaScript: `eslint <file_path>`
+  - TypeScript: `tsc --noEmit <file_path>`
+  - Java: `checkstyle <file_path>`
+  - Go: `go vet <file_path>`
+  - Rust: `cargo clippy`
+  - C/C++: `cppcheck <file_path>`
+
+- **整体代码分析**：
+  - 使用execute_shell_script编写和执行脚本，批量分析多个文件
+  - 简单脚本示例：`find . -name "*.py" | xargs pylint`
+  - 使用多工具组合：`fd -e py | xargs pylint`
+
+### read_code工具使用
+读取文件应优先使用read_code工具，而非shell命令：
+- 完整读取：使用read_code读取整个文件内容
+- 部分读取：使用read_code指定行范围
+- 大文件处理：对大型文件使用read_code指定行范围，避免全部加载
+
+### 仅在命令行工具不足时使用专用工具
+只有当fd、rg、loc和read_code工具无法获取足够信息时，才考虑使用专用工具（ask_codebase、code_review等）。在每次使用专用工具前，应先尝试使用上述工具获取所需信息。
+
+### 注意事项
+- read_code比cat或grep更适合阅读代码
+- rg比grep更快更强大，应优先使用
+- fd比find更快更易用，应优先使用
+- loc比wc -l提供更多代码统计信息，应优先使用
+- 针对不同编程语言选择对应的代码质量检查工具
 """
         # Dynamically add ask_codebase based on task complexity if really needed
-        self.agent = Agent(system_prompt=code_system_prompt, 
-                           name="CodeAgent", 
-                           auto_complete=False,
-                           is_sub_agent=False, 
-                           use_methodology=False,
+        # 处理platform参数
+        platform_instance = (PlatformRegistry().create_platform(platform) 
+                            if platform 
+                            else PlatformRegistry().get_normal_platform())
+        if model:
+            platform_instance.set_model_name(model) # type: ignore
+        
+        self.agent = Agent(system_prompt=code_system_prompt,
+                           name="CodeAgent",
+                           auto_complete=False, 
                            output_handler=[tool_registry, PatchOutputHandler()], 
-                           platform=PlatformRegistry().get_codegen_platform(), 
-                           record_methodology=False,
+                           platform=platform_instance,
                            input_handler=[shell_input_handler, file_input_handler, builtin_input_handler],
-                           need_summary=False)
+                           need_summary=need_summary)
 
     
 
@@ -212,6 +258,11 @@ def main():
     # Add argument parser
     init_env()
 
+    parser = argparse.ArgumentParser(description='Jarvis Code Agent')
+    parser.add_argument('-p', '--platform', type=str, help='Target platform name', default=None)
+    parser.add_argument('-m', '--model', type=str, help='Model name to use', default=None)
+    args = parser.parse_args()
+
     curr_dir = os.getcwd()
     git_dir = find_git_root(curr_dir)
     PrettyOutput.print(f"当前目录: {git_dir}", OutputType.INFO)
@@ -221,7 +272,7 @@ def main():
             user_input = get_multiline_input("请输入你的需求（输入空行退出）:")
             if not user_input:
                 return 0
-            agent = CodeAgent()
+            agent = CodeAgent(platform=args.platform, model=args.model, need_summary=False)
             agent.run(user_input)
             
         except Exception as e:

jarvis/jarvis_dev/main.py

@@ -425,8 +425,6 @@ def create_dev_team() -> MultiAgent:
         "file_operation", 
         "ask_codebase", 
         "lsp_get_diagnostics", 
-        "lsp_find_references", 
-        "lsp_find_definition", 
         "execute_shell",
         "code_review",
         "find_symbol",
@@ -441,8 +439,6 @@ def create_dev_team() -> MultiAgent:
         "file_operation", 
         "ask_codebase", 
         "execute_shell",
-        "lsp_find_definition",
-        "lsp_find_references",
         "find_symbol",
         "function_analyzer",
         "file_analyzer",
@@ -545,8 +541,6 @@ def create_dev_team() -> MultiAgent:
 - **file_operation**：管理技术文档和指导文件
 - **ask_codebase**：分析代码库，理解实现细节
 - **lsp_get_diagnostics**：检查代码问题和警告
-- **lsp_find_references**：查找代码引用关系
-- **lsp_find_definition**：查找符号定义位置
 - **execute_shell**：执行开发工具和命令
 - **code_review**：进行代码审查，确保代码质量
 - **find_symbol**：查找关键符号在代码中的使用
@@ -574,8 +568,6 @@ def create_dev_team() -> MultiAgent:
 - **file_operation**：管理源代码和配置文件
 - **ask_codebase**：了解代码库实现细节
 - **execute_shell**：执行开发命令和测试脚本
-- **lsp_find_definition**：查找符号定义位置
-- **lsp_find_references**：查找代码引用关系
 - **find_symbol**：查找关键符号在代码中的使用
 - **function_analyzer**：分析函数实现和优化空间
 - **file_analyzer**：分析文件结构和功能

jarvis/jarvis_lsp/base.py

@@ -25,48 +25,6 @@ class BaseLSP(ABC):
         """
         return False
     
-    @abstractmethod
-    def find_references(self, file_path: str, position: Tuple[int, int]) -> List[Dict[str, Any]]:
-        """Find all references of symbol at position.
-        
-        Args:
-            file_path: Path to the file
-            position: (line, character) tuple
-            
-        Returns:
-            List of references with location info:
-            [
-                {
-                    "uri": "file path",
-                    "range": {
-                        "start": {"line": int, "character": int},
-                        "end": {"line": int, "character": int}
-                    }
-                }
-            ]
-        """
-        return []
-    
-    @abstractmethod
-    def find_definition(self, file_path: str, position: Tuple[int, int]) -> Optional[Dict[str, Any]]:
-        """Find definition of symbol at position.
-        
-        Args:
-            file_path: Path to the file
-            position: (line, character) tuple
-            
-        Returns:
-            Location of definition:
-            {
-                "uri": "file path",
-                "range": {
-                    "start": {"line": int, "character": int},
-                    "end": {"line": int, "character": int}
-                }
-            }
-        """
-        return None
-    
     
     @abstractmethod
     def get_diagnostics(self, file_path: str) -> List[Dict[str, Any]]:

jarvis/jarvis_lsp/cpp.py

@@ -66,21 +66,6 @@ class CPPLSP(BaseLSP):
         except Exception:
             return None
     
-    def find_references(self, file_path: str, position: Tuple[int, int]) -> List[Dict[str, Any]]:
-        result = self._send_request("textDocument/references", {
-            "textDocument": {"uri": f"file://{file_path}"},
-            "position": {"line": position[0], "character": position[1]},
-            "context": {"includeDeclaration": True}
-        })
-        return result or [] # type: ignore
-    
-    def find_definition(self, file_path: str, position: Tuple[int, int]) -> Optional[Dict[str, Any]]:
-        result = self._send_request("textDocument/definition", {
-            "textDocument": {"uri": f"file://{file_path}"},
-            "position": {"line": position[0], "character": position[1]}
-        })
-        return result[0] if result else None
-
     
     def get_diagnostics(self, file_path: str) -> List[Dict[str, Any]]:
         # Send didOpen notification to trigger diagnostics

jarvis/jarvis_lsp/go.py

@@ -72,21 +72,6 @@ class GoLSP(BaseLSP):
         except Exception:
             return None
     
-    def find_references(self, file_path: str, position: Tuple[int, int]) -> List[Dict[str, Any]]:
-        result = self._send_request("textDocument/references", {
-            "textDocument": {"uri": f"file://{file_path}"},
-            "position": {"line": position[0], "character": position[1]},
-            "context": {"includeDeclaration": True}
-        })
-        return result or [] # type: ignore
-    
-    def find_definition(self, file_path: str, position: Tuple[int, int]) -> Optional[Dict[str, Any]]:
-        result = self._send_request("textDocument/definition", {
-            "textDocument": {"uri": f"file://{file_path}"},
-            "position": {"line": position[0], "character": position[1]}
-        })
-        return result[0] if result else None
-    
     def get_diagnostics(self, file_path: str) -> List[Dict[str, Any]]:
         # Send didOpen notification to trigger diagnostics
         self._send_request("textDocument/didOpen", {

jarvis/jarvis_lsp/python.py

@@ -25,25 +25,6 @@ class PythonLSP(BaseLSP):
                 return None
         return self.script_cache[file_path]
     
-    def find_references(self, file_path: str, position: Tuple[int, int]) -> List[Dict[str, Any]]:
-        script = self._get_script(file_path)
-        if not script:
-            return []
-        try:
-            refs = script.get_references(line=position[0] + 1, column=position[1])
-            return [self._location_to_dict(ref) for ref in refs]
-        except Exception:
-            return []
-    
-    def find_definition(self, file_path: str, position: Tuple[int, int]) -> Optional[Dict[str, Any]]:
-        script = self._get_script(file_path)
-        if not script:
-            return None
-        try:
-            defs = script.goto(line=position[0] + 1, column=position[1])
-            return self._location_to_dict(defs[0]) if defs else None
-        except Exception:
-            return None
     
     def _location_to_dict(self, location) -> Dict[str, Any]:
         return {

jarvis/jarvis_lsp/registry.py

@@ -9,8 +9,6 @@ from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 REQUIRED_METHODS = [
     ('initialize', ['workspace_path']),
-    ('find_references', ['file_path', 'position']),
-    ('find_definition', ['file_path', 'position']),
     ('get_diagnostics', ['file_path']),
     ('shutdown', [])
 ]
@@ -167,63 +165,3 @@ class LSPRegistry:
         with open(file_path, 'r', errors="ignore") as file:
             lines = file.readlines()
             return lines[line]
-
-def main():
-    """CLI entry point for LSP testing."""
-    import argparse
-    
-    parser = argparse.ArgumentParser(description='LSP functionality testing')
-    parser.add_argument('--language', type=str, required=True, help='Programming language')
-    parser.add_argument('--file', type=str, required=True, help='File to analyze')
-    parser.add_argument('--action', choices=['symbols', 'diagnostics', 'references', 'definition'],
-                       required=True, help='Action to perform')
-    parser.add_argument('--line', type=int, help='Line number (0-based) for references/definition')
-    parser.add_argument('--character', type=int, help='Character position for references/definition')
-    
-    args = parser.parse_args()
-    
-    # Initialize LSP
-    registry = LSPRegistry.get_global_lsp_registry()
-    lsp = registry.create_lsp(args.language)
-    
-    if not lsp:
-        PrettyOutput.print(f"没有 LSP 支持的语言: {args.language}", OutputType.WARNING)
-        return 1
-        
-    if not lsp.initialize(os.path.abspath(os.getcwd())):
-        PrettyOutput.print("LSP 初始化失败", OutputType.WARNING)
-        return 1
-    
-    try:        
-        if args.action == 'diagnostics':
-            diagnostics = lsp.get_diagnostics(args.file)
-            for diag in diagnostics:
-                severity = ['Error', 'Warning', 'Info', 'Hint'][diag['severity'] - 1]
-                PrettyOutput.print(f"{severity} 在 {diag['range']['start']['line']}:{diag['range']['start']['character']}: {diag['message']}", OutputType.INFO)
-                
-        elif args.action in ('references', 'definition'):
-            if args.line is None or args.character is None:
-                PrettyOutput.print("需要行和字符位置用于 references/definition", OutputType.WARNING)
-                return 1
-                
-            if args.action == 'references':
-                refs = lsp.find_references(args.file, (args.line, args.character))
-                for ref in refs:
-                    PrettyOutput.print(f"引用在 {ref['uri']} 在 {ref['range']['start']['line']}:{ref['range']['start']['character']}\n行: {LSPRegistry.get_line_at_position(ref['uri'], ref['range']['start']['line'])}", OutputType.INFO)
-            else:
-                defn = lsp.find_definition(args.file, (args.line, args.character))
-                if defn:
-                    PrettyOutput.print(f"定义在 {defn['uri']} 在 {defn['range']['start']['line']}:{defn['range']['start']['character']}\n行: {LSPRegistry.get_line_at_position(defn['uri'], defn['range']['start']['line'])}", OutputType.INFO)
-                else:
-                    PrettyOutput.print("没有找到定义", OutputType.WARNING)
-                    
-    except Exception as e:
-        PrettyOutput.print(f"错误: {str(e)}", OutputType.ERROR)
-        return 1
-    finally:
-        lsp.shutdown()
-    
-    return 0
-
-if __name__ == "__main__":
-    exit(main())

jarvis/jarvis_lsp/rust.py

@@ -74,21 +74,6 @@ class RustLSP(BaseLSP):
         except Exception:
             return None
     
-    def find_references(self, file_path: str, position: Tuple[int, int]) -> List[Dict[str, Any]]:
-        result = self._send_request("textDocument/references", {
-            "textDocument": {"uri": f"file://{file_path}"},
-            "position": {"line": position[0], "character": position[1]},
-            "context": {"includeDeclaration": True}
-        })
-        return result or [] # type: ignore
-    
-    def find_definition(self, file_path: str, position: Tuple[int, int]) -> Optional[Dict[str, Any]]:
-        result = self._send_request("textDocument/definition", {
-            "textDocument": {"uri": f"file://{file_path}"},
-            "position": {"line": position[0], "character": position[1]}
-        })
-        return result[0] if result else None
-    
     
     def get_diagnostics(self, file_path: str) -> List[Dict[str, Any]]:
         # Send didOpen notification to trigger diagnostics