jarvis-ai-assistant 0.1.125__py3-none-any.whl → 0.1.128__py3-none-any.whl

jarvis/jarvis_code_agent/code_agent.py

@@ -3,11 +3,15 @@ import subprocess
 import os
 from typing import Any, Tuple
 
+from yaspin import yaspin
+
 from jarvis.jarvis_agent import Agent
-from jarvis.jarvis_code_agent.patch import PatchOutputHandler, shell_input_handler
+from jarvis.jarvis_code_agent.shell_input_handler import shell_input_handler
+from jarvis.jarvis_code_agent.patch import PatchOutputHandler
 from jarvis.jarvis_platform.registry import PlatformRegistry
+from jarvis.jarvis_tools.file_operation import FileOperationTool
 from jarvis.jarvis_tools.git_commiter import GitCommitTool
-from jarvis.jarvis_tools.read_code import ReadCodeTool
+
 from jarvis.jarvis_tools.registry import ToolRegistry
 from jarvis.jarvis_utils.git_utils import find_git_root, get_commits_between, get_latest_commit_hash, has_uncommitted_changes
 from jarvis.jarvis_utils.input import get_multiline_input
@@ -81,12 +85,15 @@ def file_input_handler(user_input: str, agent: Any) -> Tuple[str, bool]:
                     "start_line": 1,  # 1-based
                     "end_line": -1
                 })
-    
+        
     # Read and process files if any were found
     if files:
-        result = ReadCodeTool().execute({"files": files})
-        if result["success"]:
-            return result["stdout"] + "\n" + prompt, False
+        with yaspin(text="正在读取文件...", color="cyan") as spinner:
+            result = FileOperationTool().execute({"operation":"read","files": files})
+            if result["success"]:
+                spinner.text = "文件读取完成"
+                spinner.ok("✅")
+                return result["stdout"] + "\n" + prompt, False
     
     return prompt, False
 
@@ -96,8 +103,7 @@ class CodeAgent:
     def __init__(self):
         self.root_dir = os.getcwd()
         tool_registry = ToolRegistry()
-        tool_registry.use_tools(["read_code",
-                                 "execute_shell", 
+        tool_registry.use_tools(["execute_shell", 
                                  "execute_shell_script",
                                  "search_web", 
                                  "create_code_agent",
@@ -107,99 +113,92 @@ class CodeAgent:
                                  "lsp_get_diagnostics", 
                                  "lsp_find_references", 
                                  "lsp_find_definition", 
-                                 "lsp_prepare_rename", 
-                                 "lsp_validate_edit"])
+                                 "lsp_prepare_rename"
+                                 ])
         code_system_prompt = """
-# Role: Senior Code Engineer
-Expert in safe, precise code modifications with rigorous validation processes.
-
-## Core Principles
-1. Safety First: Never break existing functionality
-2. Precision Engineering: Minimal, targeted changes
-3. Full Traceability: Document all decisions
-4. Validation-Driven: Verify at every stage
-
-## Tool Usage Protocol
-1. Analysis Tools:
-   - read_code: Inspect code segments before modification
-   - lsp_get_document_symbols: Map code structure
-   - lsp_find_references: Understand usage patterns
-   - lsp_find_definition: Trace implementation details
-
-2. Validation Tools:
-   - lsp_prepare_rename: Safe refactoring check
-   - lsp_validate_edit: Pre-commit validation
-   - lsp_get_diagnostics: Post-modification checks
-
-3. System Tools:
-   - execute_shell: For git operations and grep searches
-   - ask_codebase: Query code knowledge base
-   - search_web: Technical reference lookup
-
-## Workflow (PDCA Cycle)
-1. Plan:
-   - Analyze requirements with ask_user
-   - Map existing code using LSP tools
-   - Identify impact areas with find_references
-   - Create rollback plan using git
-
-2. Do:
-   - Make atomic changes in protected blocks
-   - Immediately invoke lsp_validate_edit to validate changes
-   - Automatically run lsp_get_diagnostics after each change
-   - If errors found, use lsp_find_references and lsp_find_definition for immediate remediation
-   - Validate syntax with LSP after each change
-
-3. Check:
-   - Mandatory lsp_get_diagnostics for full diagnostic report
-   - Validate all renames with lsp_prepare_rename
-   - Execute lsp_validate_edit on all modified files
-   - If errors detected, enter remediation loop until all checks pass
-
-4. Act:
-   - Commit with detailed message using git
-   - Prepare rollback script if needed
-   - Conduct post-implementation review
-
-## Code Modification Standards
-1. Pre-Change Requirements:
-   - Complete code analysis report
-   - Impact assessment matrix
-   - Rollback procedure document
-
-2. Change Implementation:
-   - Single-responsibility changes
-   - Strict line range validation (±3 line buffer)
-   - Interface compatibility checks
-
-3. Validation Checklist:
-   [ ] Execute lsp_get_diagnostics and ensure zero errors
-   [ ] All changes validated with lsp_validate_edit
-   [ ] Confirm impact scope with lsp_find_references
-   [ ] Verify rename safety with lsp_prepare_rename
-
-4. Post-Change:
-   - Code review simulation
-   - Version control audit
-   - Change log update
-
-## Critical Requirements
-1. Mandatory Analysis:
-   - Full symbol tracing before modification
-   - Cross-file impact analysis
-   - Dependency mapping
-
-2. Prohibited Actions:
-   - Proceed without passing lsp_get_diagnostics checks
-   - Submit changes without lsp_validate_edit validation
-   - Multi-feature combined changes
-   - Untested interface alterations
-
-3. Emergency Protocols:
-   - Immediately halt and rollback on lsp_get_diagnostics errors
-   - Prioritize fixing validation errors if lsp_validate_edit fails
-   - User notification on unexpected behavior
-   - Post-mortem analysis for any regression
+# 角色：高级代码工程师
+精通安全、精确的代码修改，具有严格的验证流程。
+
+## 核心原则
+1. 安全第一：绝不破坏现有功能
+2. 精准工程：最小化、针对性修改
+3. 完整可追溯：记录所有决策
+4. 验证驱动：在每个阶段进行验证
+
+## 工具使用协议
+1. 分析工具：
+   - lsp_get_document_symbols：映射代码结构
+   - lsp_find_references：理解使用模式
+   - lsp_find_definition：追踪实现细节
+
+2. 验证工具：
+   - lsp_prepare_rename：安全重构检查
+   - lsp_get_diagnostics：修改后检查
+
+3. 系统工具：
+   - execute_shell：用于git操作和grep搜索
+   - ask_codebase：查询代码知识库
+   - search_web：技术参考查找
+
+## 工作流程（PDCA循环）
+1. 计划：
+   - 使用ask_user分析需求
+   - 使用LSP工具映射现有代码
+   - 使用find_references识别影响区域
+   - 使用git创建回滚计划
+
+2. 执行：
+   - 在受保护的块中进行原子修改
+   - 每次更改后自动运行lsp_get_diagnostics
+   - 如果发现错误，使用lsp_find_references和lsp_find_definition进行即时修复
+   - 每次更改后使用LSP验证语法
+
+3. 检查：
+   - 强制使用lsp_get_diagnostics进行完整诊断报告
+   - 使用lsp_preprepare_rename验证所有重命名
+   - 如果检测到错误，进入修复循环直到所有检查通过
+
+4. 行动：
+   - 使用git提交详细消息
+   - 准备回滚脚本（如果需要）
+   - 进行实施后审查
+
+## 代码修改标准
+1. 修改前要求：
+   - 完整的代码分析报告
+   - 影响评估矩阵
+   - 回滚程序文档
+
+2. 修改实施：
+   - 单一职责修改
+   - 严格的代码范围验证（±3行缓冲区）
+   - 接口兼容性检查
+
+3. 验证清单：
+   [ ] 执行lsp_get_diagnostics并确保零错误
+   [ ] 使用lsp_find_references确认影响范围
+   [ ] 使用lsp_prepare_rename验证重命名安全性
+
+4. 修改后：
+   - 代码审查模拟
+   - 版本控制审计
+   - 更新变更日志
+
+## 关键要求
+1. 强制分析：
+   - 修改前完整符号追踪
+   - 跨文件影响分析
+   - 依赖关系映射
+
+2. 禁止操作：
+   - 未通过lsp_get_diagnostics检查继续操作
+   - 多个功能组合修改
+   - 未经测试的接口修改
+
+3. 紧急协议：
+   - lsp_get_diagnostics出现错误时立即停止并回滚
+   - 出现意外行为时通知用户
+   - 对任何回归进行事后分析
 """
         self.agent = Agent(system_prompt=code_system_prompt, 
                            name="CodeAgent", 
@@ -215,12 +214,17 @@ Expert in safe, precise code modifications with rigorous validation processes.
     
 
     def _init_env(self):
-        curr_dir = os.getcwd()
-        git_dir = find_git_root(curr_dir)
-        self.root_dir = git_dir
-        if has_uncommitted_changes():
-            git_commiter = GitCommitTool()
-            git_commiter.execute({})
+        with yaspin(text="正在初始化环境...", color="cyan") as spinner: 
+            curr_dir = os.getcwd()
+            git_dir = find_git_root(curr_dir)
+            self.root_dir = git_dir
+            if has_uncommitted_changes():
+                with spinner.hidden():
+                    git_commiter = GitCommitTool()
+                    git_commiter.execute({})
+            else:
+                spinner.text = "环境初始化完成"
+            spinner.ok("✅")
 
     
 
@@ -235,10 +239,13 @@ Expert in safe, precise code modifications with rigorous validation processes.
         """
         try:
             self._init_env()
-            start_commit = get_latest_commit_hash()
             
+            start_commit = get_latest_commit_hash()
             
-            self.agent.run(user_input)
+            try:
+                self.agent.run(user_input)
+            except Exception as e:
+                PrettyOutput.print(f"执行失败: {str(e)}", OutputType.WARNING)
             
             end_commit = get_latest_commit_hash()
             # Print commit history between start and end commits
@@ -296,4 +303,4 @@ def main():
     return 0
 
 if __name__ == "__main__":
-    exit(main())
+    exit(main())

jarvis/jarvis_code_agent/patch.py

@@ -2,11 +2,13 @@ import re
 from typing import Dict, Any, Tuple
 import os
 
+from yaspin import yaspin
+
 from jarvis.jarvis_agent.output_handler import OutputHandler
 from jarvis.jarvis_platform.registry import PlatformRegistry
 from jarvis.jarvis_tools.git_commiter import GitCommitTool
-from jarvis.jarvis_tools.file_operation import FileOperationTool
 from jarvis.jarvis_tools.execute_shell_script import ShellScriptTool
+from jarvis.jarvis_tools.file_operation import FileOperationTool
 from jarvis.jarvis_utils.config import is_confirm_before_apply_patch
 from jarvis.jarvis_utils.git_utils import get_commits_between, get_latest_commit_hash
 from jarvis.jarvis_utils.input import get_multiline_input
@@ -26,31 +28,31 @@ class PatchOutputHandler(OutputHandler):
     
     def prompt(self) -> str:
         return """
-# 🛠️ Contextual Code Patch Specification
-Use <PATCH> blocks to specify code changes:
+# 🛠️ 上下文代码补丁规范
+使用<PATCH>块来指定代码更改：
 --------------------------------
 <PATCH>
-File: [file_path]
-Reason: [change_reason]
-[contextual_code_snippet]
+File: [文件路径]
+Reason: [修改原因]
+[上下文代码片段]
 </PATCH>
 --------------------------------
-Rules:
-1. Code snippets must include sufficient context (3 lines before/after)
-2. I can see full code, so only show modified code sections
-3. Preserve original indentation and formatting
-4. For new files, provide complete code
-5. When modifying existing files, retain surrounding unchanged code
-Example:
+规则：
+1. 代码片段必须包含足够的上下文（前后各3行）
+2. 我可以看到完整代码，所以只需显示修改的代码部分
+3. 保留原始缩进和格式
+4. 对于新文件，提供完整代码
+5. 修改现有文件时，保留周围未更改的代码
+示例：
 <PATCH>
 File: src/utils/math.py
-Reason: Fix zero division handling
+Reason: 修复除零处理
 def safe_divide(a, b):
-    # Add parameter validation
+    # 添加参数验证
     if b == 0:
-        raise ValueError("Divisor cannot be zero")
+        raise ValueError("除数不能为零")
     return a / b
-# existing code ...
+# 现有代码 ...
 def add(a, b):
     return a + b
 </PATCH>
@@ -73,50 +75,63 @@ def _parse_patch(patch_str: str) -> Dict[str, str]:
 
 def apply_patch(output_str: str) -> str:
     """Apply patches to files"""
-    try:
-        patches = _parse_patch(output_str)
-    except Exception as e:
-        PrettyOutput.print(f"解析补丁失败: {str(e)}", OutputType.ERROR)
-        return ""
-    
-    # 获取当前提交hash作为起始点
-    start_hash = get_latest_commit_hash()
-    
-    # 按文件逐个处理
-    for filepath, patch_content in patches.items():
+    with yaspin(text="正在应用补丁...", color="cyan") as spinner:
         try:
-            handle_code_operation(filepath, patch_content)
-            PrettyOutput.print(f"文件 {filepath} 处理完成", OutputType.SUCCESS)
+            patches = _parse_patch(output_str)
         except Exception as e:
-            revert_file(filepath)  # 回滚单个文件
-            PrettyOutput.print(f"文件 {filepath} 处理失败: {str(e)}", OutputType.ERROR)
-    
-    final_ret = ""
-    diff = get_diff()
-    if diff:
-        PrettyOutput.print(diff, OutputType.CODE, lang="diff")
-        if handle_commit_workflow():
-            # 获取提交信息
-            end_hash = get_latest_commit_hash()
-            commits = get_commits_between(start_hash, end_hash)
-            
-            # 添加提交信息到final_ret
-            if commits:
-                final_ret += "✅ The patches have been applied\n"
-                final_ret += "Commit History:\n"
-                for commit_hash, commit_message in commits:
-                    final_ret += f"- {commit_hash[:7]}: {commit_message}\n"
+            PrettyOutput.print(f"解析补丁失败: {str(e)}", OutputType.ERROR)
+            return ""
+        
+        # 获取当前提交hash作为起始点
+        spinner.text= "开始获取当前提交hash..."
+        start_hash = get_latest_commit_hash()
+        spinner.write("✅ 当前提交hash获取完成")
+        
+        # 按文件逐个处理
+        for filepath, patch_content in patches.items():
+            try:
+                spinner.text = f"正在处理文件: {filepath}"
+                with spinner.hidden():
+                    handle_code_operation(filepath, patch_content)
+                spinner.write(f"✅ 文件 {filepath} 处理完成")
+            except Exception as e:
+                spinner.text = f"文件 {filepath} 处理失败: {str(e)}, 回滚文件"
+                revert_file(filepath)  # 回滚单个文件
+                spinner.write(f"✅ 文件 {filepath} 回滚完成")
+        
+        final_ret = ""
+        diff = get_diff()
+        if diff:
+            PrettyOutput.print(diff, OutputType.CODE, lang="diff")
+            with spinner.hidden():
+                commited = handle_commit_workflow()
+            if commited:
+                # 获取提交信息
+                end_hash = get_latest_commit_hash()
+                commits = get_commits_between(start_hash, end_hash)
+                
+                # 添加提交信息到final_ret
+                if commits:
+                    final_ret += "✅ 补丁已应用\n"
+                    final_ret += "提交信息:\n"
+                    for commit_hash, commit_message in commits:
+                        final_ret += f"- {commit_hash[:7]}: {commit_message}\n"
+                    
+                    final_ret += f"应用补丁:\n{diff}"
+                    
+                else:
+                    final_ret += "✅ 补丁已应用（没有新的提交）"
             else:
-                final_ret += "✅ The patches have been applied (no new commits)"
+                final_ret += "❌ 我不想提交代码\n"
+                final_ret += "补丁预览:\n"
+                final_ret += diff
         else:
-            final_ret += "❌ I don't want to commit the code"
-    else:
-        final_ret += "❌ There are no changes to commit"
-    # 用户确认最终结果
-    PrettyOutput.print(final_ret, OutputType.USER)
-    if not is_confirm_before_apply_patch() or user_confirm("是否使用此回复？", default=True):
-        return final_ret
-    return get_multiline_input("请输入自定义回复")
+            final_ret += "❌ 没有要提交的更改\n"
+        # 用户确认最终结果
+        PrettyOutput.print(final_ret, OutputType.USER)
+        if not is_confirm_before_apply_patch() or user_confirm("是否使用此回复？", default=True):
+            return final_ret
+        return get_multiline_input("请输入自定义回复")
 def revert_file(filepath: str):
     """增强版git恢复，处理新文件"""
     import subprocess
@@ -170,87 +185,91 @@ def handle_commit_workflow()->bool:
     return commit_result["success"]
 
 # New handler functions below ▼▼▼
-def handle_code_operation(filepath: str, patch_content: str) -> str:
+def handle_code_operation(filepath: str, patch_content: str) -> bool:
     """处理基于上下文的代码片段"""
-    try:
-        if not os.path.exists(filepath):
-            # 新建文件
-            os.makedirs(os.path.dirname(filepath), exist_ok=True)
-            open(filepath, 'w', encoding='utf-8').close()
-        old_file_content = FileOperationTool().execute({"operation": "read", "files": [{"path": filepath}]})
-        if not old_file_content["success"]:
-            return f"文件读取失败: {old_file_content['stderr']}"
-        
-        prompt = f"""
-You are a code reviewer, please review the following code and merge the code with the context.
-Original Code:
-{old_file_content["stdout"]}
-Patch:
-{patch_content}
-"""
-        prompt += f"""
-Please merge the code with the context and return the fully merged code.
+    with yaspin(text=f"正在修改文件 {filepath}...", color="cyan") as spinner:
+        try:
+            if not os.path.exists(filepath):
+                # 新建文件
+                spinner.text = "文件不存在，正在创建文件..."
+                os.makedirs(os.path.dirname(filepath), exist_ok=True)
+                open(filepath, 'w', encoding='utf-8').close()
+                spinner.write("✅ 文件创建完成")
+            old_file_content = FileOperationTool().execute({"operation": "read", "files": [{"path": filepath}]})
+            if not old_file_content["success"]:
+                spinner.write("❌ 文件读取失败")
+                return False
+            
+            prompt = f"""
+    你是一个代码审查员，请审查以下代码并将其与上下文合并。
+    原始代码:
+    {old_file_content["stdout"]}
+    补丁内容:
+    {patch_content}
+    """
+            prompt += f"""
+    请将代码与上下文合并并返回完整的合并代码，每次最多输出300行代码。
 
-Requirements:
-1. Strictly preserve original code formatting and indentation
-2. Only include actual code content in <MERGED_CODE> block
-3. Absolutely NO markdown code blocks (```) or backticks
-4. Maintain exact line numbers from original code except for changes
+    要求:
+    1. 严格保留原始代码的格式、空行和缩进
+    2. 仅在<MERGED_CODE>块中包含实际代码内容，包括空行和缩进
+    3. 绝对不要使用markdown代码块（```）或反引号，除非修改的是markdown文件
+    4. 除了合并后的代码，不要输出任何其他文本
+    5. 所有代码输出完成后，输出<!!!FINISHED!!!>
 
-Output Format:
-<MERGED_CODE>
-[merged_code]
-</MERGED_CODE>
-"""
-        model = PlatformRegistry().get_codegen_platform()
-        model.set_suppress_output(False)
-        count = 5
-        start_line = -1
-        end_line = -1
-        response = []
-        while count > 0:
-            count -= 1
-            response.extend(model.chat_until_success(prompt).splitlines())
-            try:
-                start_line = response.index("<MERGED_CODE>") + 1
-            except:
-                pass
-            try:
-                end_line = response.index("</MERGED_CODE>")
-            except:
-                pass
-            if start_line == -1:
-                PrettyOutput.print(f"❌ 为文件 {filepath} 应用补丁失败", OutputType.WARNING)
-                return f"代码合并失败"
-            if end_line == -1:
-                last_line = response[-1]
-                prompt = f"""
-                continue with the last line:
-                {last_line}
-                """
-                response.pop() # 删除最后一行
-                continue
-            if end_line < start_line:
-                PrettyOutput.print(f"❌ 为文件 {filepath} 应用补丁失败", OutputType.WARNING)
-                return f"代码合并失败"
-            break
-        # 写入合并后的代码
-        with open(filepath, 'w', encoding='utf-8') as f:
-            f.write("\n".join(response[start_line:end_line]))
-        PrettyOutput.print(f"✅ 为文件 {filepath} 应用补丁成功", OutputType.SUCCESS)
-        return ""
-    except Exception as e:
-        return f"文件操作失败: {str(e)}"
-def shell_input_handler(user_input: str, agent: Any) -> Tuple[str, bool]:
-    lines = user_input.splitlines()
-    cmdline = [line for line in lines if line.startswith("!")]
-    if len(cmdline) == 0:
-        return user_input, False
-    else:
-        script = '\n'.join([c[1:] for c in cmdline])
-        PrettyOutput.print(script, OutputType.CODE, lang="bash")
-        if user_confirm(f"是否要执行以上shell脚本？", default=True):
-            ShellScriptTool().execute({"script_content": script})
-            return "", True
-        return user_input, False
-    
+    输出格式:
+    <MERGED_CODE>
+    [merged_code]
+    </MERGED_CODE>
+    """
+            PrettyOutput.section("代码生成", OutputType.SYSTEM)
+            model = PlatformRegistry().get_codegen_platform()
+            model.set_suppress_output(False)
+            count = 30
+            start_line = -1
+            end_line = -1
+            code = []
+            finished = False
+            with spinner.hidden():
+                while count>0:
+                    count -= 1
+                    response = model.chat_until_success(prompt).splitlines()
+                    try:
+                        start_line = response.index("<MERGED_CODE>") + 1
+                    except:
+                        return False
+                    try:
+                        end_line = response.index("</MERGED_CODE>")
+                    except:
+                        return False
+                    code = response[start_line:end_line]
+                    try: 
+                        response.index("<!!!FINISHED!!!>")
+                        finished = True
+                        break
+                    except:
+                        prompt += f"""继续输出接下来的300行代码
+                        要求：
+                        1. 严格保留原始代码的格式、空行和缩进
+                        2. 仅在<MERGED_CODE>块中包含实际代码内容，包括空行和缩进
+                        3. 绝对不要使用markdown代码块（```）或反引号，除非修改的是markdown文件
+                        4. 除了合并后的代码，不要输出任何其他文本
+                        5. 所有代码输出完成后，输出<!!!FINISHED!!!>
+                        """
+                        pass
+                if not finished:
+                    spinner.text = "生成代码失败"
+                    spinner.fail("❌")
+                    return False
+            # 写入合并后的代码
+            spinner.text = "写入合并后的代码..."
+            with open(filepath, 'w', encoding='utf-8') as f:
+                f.write("\n".join(code)+"\n")
+            spinner.write("✅ 合并后的代码写入完成")
+            spinner.text = "代码修改完成"
+            spinner.ok("✅")
+            return True
+        except Exception as e:
+            spinner.text = "代码修改失败"
+            spinner.fail("❌")
+            return False

jarvis/jarvis_code_agent/shell_input_handler.py

@@ -0,0 +1,22 @@
+
+
+from typing import Any, Tuple
+
+from jarvis.jarvis_tools.execute_shell_script import ShellScriptTool
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+from jarvis.jarvis_utils.utils import user_confirm
+
+
+def shell_input_handler(user_input: str, agent: Any) -> Tuple[str, bool]:
+    lines = user_input.splitlines()
+    cmdline = [line for line in lines if line.startswith("!")]
+    if len(cmdline) == 0:
+        return user_input, False
+    else:
+        script = '\n'.join([c[1:] for c in cmdline])
+        PrettyOutput.print(script, OutputType.CODE, lang="bash")
+        if user_confirm(f"是否要执行以上shell脚本？", default=True):
+            ShellScriptTool().execute({"script_content": script})
+            return "", True
+        return user_input, False
+