jarvis-ai-assistant 0.1.115__py3-none-any.whl → 0.1.117__py3-none-any.whl

jarvis/jarvis_code_agent/code_agent.py

@@ -1,13 +1,15 @@
 import os
 from typing import Dict, List
 
-from jarvis.agent import Agent
-from jarvis.jarvis_code_agent.patch import apply_patch
+from jarvis.jarvis_agent import Agent
+from jarvis.jarvis_code_agent.file_select import file_input_handler
+from jarvis.jarvis_code_agent.patch import PatchOutputHandler
 from jarvis.jarvis_code_agent.relevant_files import find_relevant_information
 from jarvis.jarvis_platform.registry import PlatformRegistry
 from jarvis.jarvis_tools.git_commiter import GitCommitTool
 from jarvis.jarvis_tools.registry import ToolRegistry
-from jarvis.utils import OutputType, PrettyOutput, get_multiline_input, has_uncommitted_changes, init_env, find_git_root
+from jarvis.jarvis_tools.read_code import ReadCodeTool
+from jarvis.jarvis_utils import OutputType, PrettyOutput, get_multiline_input, has_uncommitted_changes, init_env, find_git_root
 
 
 class CodeAgent:
@@ -26,113 +28,120 @@ class CodeAgent:
                                  "lsp_find_definition", 
                                  "lsp_prepare_rename", 
                                  "lsp_validate_edit"])
-        code_system_prompt = """You are a code agent responsible for modifying code. Your primary task is to understand existing code first and ensure compatibility with the current system.
-
-# Critical First Steps
-1. READ and UNDERSTAND existing code thoroughly
-2. Identify current patterns and conventions
-3. Map out affected components and their interactions
-4. Plan changes that maintain system integrity
-
-# Code Completeness Requirements
-1. Implementation Must Be Complete
-   • NO TODOs or placeholder comments
-   • NO unfinished functions
-   • NO stub implementations
-   • All error cases must be handled
-   • All edge cases must be covered
-
-2. Documentation Must Be Complete
-   • All functions must have docstrings
-   • All parameters must be documented
-   • Return values must be specified
-   • Exceptions must be documented
-   • Complex logic must be explained
-
-# Patch Format
-<PATCH>
-path/file start,end
-new_content
-</PATCH>
-
-Key Rules:
-• One modification per patch block
-• Line numbers are based on original file
-• Start line is included, end line is excluded
-• Same start/end number: insert before that line
-• Start=0, end=0: create new file with content
-
-# Code Compatibility Requirements
-1. System Integration
-   • MUST preserve existing API contracts
-   • MUST maintain current function signatures
-   • MUST keep data structure compatibility
-   • MUST follow error handling patterns
-
-2. Style Consistency
-   • Match existing naming conventions exactly
-   • Follow established code organization
-   • Use current import style and order
-   • Maintain comment style and level of detail
-
-3. Pattern Alignment
-   • Reuse existing error handling approaches
-   • Follow established design patterns
-   • Use current logging conventions
-   • Keep configuration consistency
-
-# Development Process
-1. ANALYZE (Current Code)
-   • Read and understand existing implementations
-   • Map out current code structure
-   • Identify established patterns
-   • Note key dependencies
-
-2. ASSESS (Changes)
-   • Evaluate impact on existing code
-   • Check all dependencies
-   • Verify API compatibility
-   • Consider side effects
-
-3. IMPLEMENT (Carefully)
-   • Make minimal necessary changes
-   • Follow existing patterns exactly
-   • Preserve all interfaces
-   • Maintain backward compatibility
-   • Implement completely - no TODOs
-
-# File Handling
-Large Files (>200 lines):
-1. Use grep/find to locate relevant sections
+        code_system_prompt = """
+# 🤖 Role Definition
+You are a code agent specialized in code modification. Your primary responsibility is to understand existing code thoroughly and ensure system compatibility.
+
+# 🎯 Core Responsibilities
+- Analyze and understand existing code
+- Maintain system compatibility
+- Generate high-quality code changes
+- Ensure complete implementation
+- Follow project conventions
+
+# 🔄 Development Workflow
+1. Code Analysis
+   - Read and understand existing code thoroughly
+   - Map out affected components
+   - Identify patterns and conventions
+   - Document dependencies
+
+2. Change Planning
+   - Evaluate impact on system
+   - Verify API compatibility
+   - Consider side effects
+   - Plan minimal changes
+
+3. Implementation
+   - Follow existing patterns exactly
+   - Maintain backward compatibility
+   - Complete implementation fully
+   - Document all changes
+
+# 📋 Code Quality Requirements
+## Implementation Completeness
+- NO TODOs or placeholders
+- NO unfinished functions
+- NO stub implementations
+- Full error handling
+- Complete edge cases
+
+## Documentation Standards
+- Function docstrings
+- Parameter documentation
+- Return value specifications
+- Exception documentation
+- Complex logic explanation
+
+## System Compatibility
+- Preserve API contracts
+- Maintain function signatures
+- Keep data structure compatibility
+- Follow error handling patterns
+
+## Style Guidelines
+- Match naming conventions
+- Follow code organization
+- Use consistent import style
+- Maintain comment patterns
+
+# 🛠️ Available Tools
+## Primary Tools
+- `read_code`: MUST use to understand existing code
+- `lsp_*`: Code analysis tools
+- `execute_shell`: For code searches
+- `ask_user`: When clarification needed
+
+## LSP Tools
+- `lsp_get_document_symbols`
+- `lsp_get_diagnostics`
+- `lsp_find_references`
+- `lsp_find_definition`
+- `lsp_prepare_rename`
+- `lsp_validate_edit`
+
+# 📝 File Modification Rules
+- One modification per patch block
+- Line numbers based on original file
+- Start line included, end line excluded
+- Same start/end: insert before line
+- Start=0, end=0: create new file
+
+# 📚 Large File Handling (>200 lines)
+1. Use grep/find for section location
 2. Read specific ranges with read_code
 3. Apply targeted changes
 
-# Available Tools
-Primary:
-• read_code - MUST use to understand existing code
-• LSP tools for code analysis
-• execute_shell for searches
-• ask_user when uncertain
-
-# Quality Requirements
-Every Change Must:
-✓ Be based on thorough code reading
-✓ Preserve all interfaces
-✓ Match existing style exactly
-✓ Handle errors consistently
-✓ Maintain documentation
-✓ Follow project patterns
-✓ Be completely implemented
-✓ Have no TODOs or stubs"""
+# ❗ Critical Rules
+1. MUST read code before changes
+2. MUST preserve interfaces
+3. MUST follow existing patterns
+4. MUST complete implementation
+5. MUST document thoroughly
+6. MUST handle errors
+7. NO TODOs or stubs
+8. ONE modification per patch
+
+# ✅ Quality Checklist
+Before submitting changes, verify:
+□ Based on thorough code reading
+□ Preserves all interfaces
+□ Matches existing style
+□ Handles all errors
+□ Complete documentation
+□ Follows project patterns
+□ No TODOs or stubs
+□ One change per patch
+"""
         self.agent = Agent(system_prompt=code_system_prompt, 
                            name="CodeAgent", 
                            auto_complete=False,
                            is_sub_agent=False, 
                            use_methodology=False,
-                           tool_registry=tool_registry, 
+                           output_handler=[tool_registry, PatchOutputHandler()], 
                            platform=PlatformRegistry().get_codegen_platform(), 
                            record_methodology=False,
-                           output_handler_after_tool=[apply_patch],
+                           input_handler=[file_input_handler],
                            need_summary=False)
 
     
@@ -160,6 +169,10 @@ Every Change Must:
         # Then try to add file contents
         for file in files:
             prompt_parts.append(f'''- {file['file']} ({file['reason']})''')
+
+        result = ReadCodeTool().execute({"files": [{"file": file["file"], "reason": file["reason"]} for file in files]})
+        if result["success"]:
+            prompt_parts.append(result["stdout"])
                 
         return "\n".join(prompt_parts)
 

jarvis/jarvis_code_agent/file_select.py

@@ -3,7 +3,8 @@ import re
 from typing import Dict, List
 from prompt_toolkit import PromptSession
 from prompt_toolkit.completion import Completer, Completion
-from jarvis.utils import OutputType, PrettyOutput, get_single_line_input, user_confirm
+from jarvis.jarvis_tools.read_code import ReadCodeTool
+from jarvis.jarvis_utils import OutputType, PrettyOutput, get_single_line_input, user_confirm
 
 
 def _parse_file_selection(input_str: str, max_index: int) -> List[int]:
@@ -135,6 +136,9 @@ def select_files(related_files: List[Dict[str, str]], root_dir: str) -> List[Dic
     for i, file in enumerate(related_files, 1):
         output += f"[{i}] {file['file']} ({file['reason']})\n"
 
+    # Filter out files that do not exist
+    related_files = [f for f in related_files if os.path.isfile(os.path.join(root_dir, f["file"]))]
+
     PrettyOutput.print(output, OutputType.INFO, lang="markdown")
     
     if len(related_files) > 0:
@@ -175,9 +179,10 @@ def select_files(related_files: List[Dict[str, str]], root_dir: str) -> List[Dic
                     continue
                     
                 # Display matching files
-                PrettyOutput.print("找到以下匹配的文件:", OutputType.INFO)
+                tips = "找到以下匹配的文件:"
                 for i, path in enumerate(matches, 1):
-                    PrettyOutput.print(f"[{i}] {path}", OutputType.INFO)
+                    tips += f"\n[{i}] {path}"
+                PrettyOutput.print(tips, OutputType.INFO)
                     
                 # Let the user select
                 numbers = get_single_line_input("请选择要添加的文件编号（支持: 1,3-6格式, 按回车选择所有）").strip()
@@ -192,16 +197,32 @@ def select_files(related_files: List[Dict[str, str]], root_dir: str) -> List[Dic
                 paths_to_add = [file_path]
             
             # Add selected files
+            tips = "添加以下文件:"
             for path in paths_to_add:
                 full_path = os.path.join(root_dir, path)
                 if not os.path.isfile(full_path):
-                    PrettyOutput.print(f"文件不存在: {path}", OutputType.ERROR)
+                    tips += f"\n文件不存在: {path}"
                     continue
                 
                 try:
                     selected_files.append({"file": path, "reason": "User Added"})
-                    PrettyOutput.print(f"文件已添加: {path}", OutputType.SUCCESS)
+                    tips += f"\n文件已添加: {path}"
                 except Exception as e:
-                    PrettyOutput.print(f"读取文件失败: {str(e)}", OutputType.ERROR)
+                    tips += f"\n读取文件失败: {str(e)}"
+    selected_files = [f for f in selected_files if os.path.isfile(os.path.join(root_dir, f["file"]))]
+    PrettyOutput.print(tips, OutputType.INFO)
+    return selected_files
+
+def file_input_handler(user_input: str) -> str:
+    prompt = user_input
+    files = []
+    sm = re.findall(r'`(.+?)`', user_input)
+    if sm:
+        for s in sm:
+            if os.path.isfile(s[0]):
+                files.append(s[0])
+    result = ReadCodeTool().execute({"files": files})
+    if result["success"]:
+        return result["stdout"] + "\n" + prompt
     
-    return selected_files
+    return prompt

jarvis/jarvis_code_agent/patch.py

@@ -1,8 +1,86 @@
 import re
-from typing import Dict, Any, List
+from typing import Dict, Any, List, Tuple
 import os
+from jarvis.jarvis_agent.output_handler import OutputHandler
 from jarvis.jarvis_tools.git_commiter import GitCommitTool
-from jarvis.utils import OutputType, PrettyOutput, get_multiline_input, has_uncommitted_changes, user_confirm
+from jarvis.jarvis_utils import OutputType, PrettyOutput, get_multiline_input, has_uncommitted_changes, user_confirm
+
+
+class PatchOutputHandler(OutputHandler):
+    def name(self) -> str:
+        return "PATCH"
+
+    def handle(self, response: str) -> Tuple[bool, Any]:
+        return False, apply_patch(response)
+    
+    def can_handle(self, response: str) -> bool:
+        if _parse_patch(response):
+            return True
+        return False
+    
+    def prompt(self) -> str:
+        return """
+# 📝 Patch Format
+Use patch blocks to specify code changes:
+
+```
+<PATCH>
+path/to/file start,end
+new_content
+</PATCH>
+```
+
+# 📋 Format Rules
+1. File Path
+   - Use relative path from project root
+   - Must be exact and case-sensitive
+   - Example: src/module/file.py
+
+2. Line Numbers
+   - Format: start,end
+   - start: First line to modify (included)
+   - end: Line after last modified line
+   - Both numbers are based on original file
+
+3. Special Cases
+   - Insert: Use same number for start,end
+   - New File: Use 0,0
+   - Example: "5,5" inserts before line 5
+
+# 📌 Examples
+## Modify Existing Code
+```
+<PATCH>
+src/utils.py 10,15
+def new_function():
+    return "modified"
+</PATCH>
+```
+
+## Insert New Code
+```
+<PATCH>
+src/main.py 20,20
+    new_line_here()
+</PATCH>
+```
+
+## Create New File
+```
+<PATCH>
+src/new_file.py 0,0
+def new_function():
+    pass
+</PATCH>
+```
+
+# ❗ Important Rules
+1. ONE modification per patch block
+2. Include necessary context
+3. Match existing code style
+4. Preserve indentation
+5. Use exact file paths
+"""
 
 
 def _parse_patch(patch_str: str) -> Dict[str, List[Dict[str, Any]]]:

jarvis/jarvis_code_agent/relevant_files.py

@@ -5,55 +5,95 @@ from typing import Dict, List, Optional, Tuple
 from jarvis.jarvis_code_agent.file_select import select_files
 from jarvis.jarvis_codebase.main import CodeBase
 from jarvis.jarvis_platform.registry import PlatformRegistry
-from jarvis.utils import OutputType, PrettyOutput
+from jarvis.jarvis_utils import OutputType, PrettyOutput
 
 def make_question(requirement: str) -> Optional[str]:
     """Generate structured questions to gather necessary information for the requirement."""
-    prompt = f"""You are a code analysis expert who helps developers understand existing system implementations. Generate specific questions to investigate:
-- Current system implementations
-- Existing interfaces and integration points
-- Extension mechanisms and patterns
-- Related components and their interactions
-
-Key Instructions:
-1. Focus on understanding the EXISTING system
-2. Ask about interfaces, hooks, and extension points
-3. Investigate integration patterns and dependencies
-4. Explore current implementation details
-
-For example:
-BAD: "How should we implement the new feature?"
-GOOD: "What are the existing extension points in the authentication system that we can use to add the new OAuth provider? Specifically, how does AuthProvider interface work and where is it currently used?"
-
-Consider these investigation aspects:
-
-1. System Architecture:
-   - "What are the existing interfaces/classes that handle [functionality]?"
-   - "How is [feature] currently integrated with other components?"
-   - "Where are the extension points for [system component]?"
-
-2. Implementation Details:
-   - "What is the current workflow for [operation] in the system?"
-   - "How does the system expose hooks/callbacks for [functionality]?"
-   - "Which interfaces/abstract classes are used for [feature] extensibility?"
-
-3. Integration Patterns:
-   - "How do existing components integrate with [system part]?"
-   - "What are the current integration points for [feature]?"
-   - "How does the system handle extensions to [component]?"
-
-4. Extension Mechanisms:
-   - "What patterns are used for extending [functionality]?"
-   - "How do existing plugins/extensions connect to [system]?"
-   - "Where are the configuration points for [feature] customization?"
+    prompt = f"""
+# 🔍 Role Definition
+You are a code analysis expert who helps developers understand existing system implementations by asking targeted questions.
 
-User Requirement:
-{requirement}
+# 🎯 Core Objectives
+- Understand current system implementations
+- Identify integration points and interfaces
+- Discover extension mechanisms
+- Map component interactions
+
+# 📋 Question Categories
+## 1. System Architecture
+Focus on system structure and design:
+- Existing interfaces and classes
+- Component integration patterns
+- Extension points and hooks
+- System boundaries
+
+## 2. Implementation Details
+Explore current codebase:
+- Workflow implementations
+- Hook and callback systems
+- Interface hierarchies
+- Extension mechanisms
+
+## 3. Integration Patterns
+Understand connection points:
+- Component interactions
+- Integration interfaces
+- Extension methods
+- Plugin systems
+
+## 4. Extension Mechanisms
+Identify customization options:
+- Extension patterns
+- Plugin architectures
+- Configuration systems
+- Customization points
+
+# 📝 Question Guidelines
+## Good Questions
+- "What interfaces currently handle user authentication?"
+- "How does the system expose extension points for plugins?"
+- "Where are the existing hooks for custom providers?"
+
+## Bad Questions
+- "How should we implement the new feature?"
+- "What's the best way to add this?"
+- "Should we create a new class?"
 
-Output Format:
+# 🎨 Question Template
+```
 <QUESTION>
-[Write 3-5 specific questions focusing on existing implementations and extension points. Each question should help understand how to integrate with or extend the current system]
+[3-5 specific questions about existing implementations:
+1. System architecture question
+2. Implementation details question
+3. Integration or extension question]
 </QUESTION>
+```
+
+# 🔎 Investigation Focus
+1. Current System
+   - Existing implementations
+   - Active interfaces
+   - Current patterns
+
+2. Integration Points
+   - Connection methods
+   - Extension hooks
+   - Plugin systems
+
+3. Extension Options
+   - Customization points
+   - Configuration options
+   - Extension patterns
+
+# ❗ Important Rules
+1. Focus on EXISTING code
+2. Ask about current patterns
+3. Explore extension points
+4. Investigate interfaces
+5. Map dependencies
+
+User Requirement:
+{requirement}
 """
     model = PlatformRegistry().get_thinking_platform()
     response = model.chat_until_success(prompt)

jarvis/jarvis_codebase/main.py

@@ -7,8 +7,8 @@ from typing import List, Tuple, Optional, Dict
 from jarvis.jarvis_platform.registry import PlatformRegistry
 import concurrent.futures
 from concurrent.futures import ThreadPoolExecutor
-from jarvis.utils import OutputType, PrettyOutput, find_git_root, get_context_token_count, get_embedding, get_file_md5, get_max_token_count, get_thread_count, load_embedding_model, user_confirm
-from jarvis.utils import init_env
+from jarvis.jarvis_utils import OutputType, PrettyOutput, find_git_root, get_context_token_count, get_embedding, get_file_md5, get_max_token_count, get_thread_count, load_embedding_model, user_confirm
+from jarvis.jarvis_utils import init_env
 import argparse
 import pickle
 import lzma  # 添加 lzma 导入
@@ -787,23 +787,48 @@ Please provide 10 search-optimized expressions in the specified format.
         
         if not files_from_codebase:
             PrettyOutput.print("没有找到相关文件", output_type=OutputType.WARNING)
-            return [],""
+            return [], ""
         
-        # Build enhanced prompt
-        prompt = f"""Based on the following code files, please provide a comprehensive and accurate answer to the user's question.
-
-Important guidelines:
-1. Focus on code-specific details and implementation
-2. Explain technical concepts clearly
-3. Include relevant code snippets when helpful
-4. If the code doesn't fully answer the question, indicate what's missing
-5. Answer in user's language.
-6. Answer with professional language.
-
+        prompt = f"""
+# 🤖 Role Definition
+You are a code analysis expert who provides comprehensive and accurate answers about codebases.
+
+# 🎯 Core Responsibilities
+- Analyze code files thoroughly
+- Explain technical concepts clearly
+- Provide relevant code examples
+- Identify missing information
+- Answer in user's language
+
+# 📋 Response Requirements
+## Content Quality
+- Focus on implementation details
+- Be technically precise
+- Include relevant code snippets
+- Indicate any missing information
+- Use professional terminology
+
+## Response Format
+```yaml
+- question: [Restate the question]
+  answer: |
+    [Detailed technical answer with:
+    - Implementation details
+    - Code examples (if relevant)
+    - Missing information (if any)
+    - Related technical concepts]
+
+- question: [Follow-up question if needed]
+  answer: |
+    [Additional technical details]
+```
+
+# 🔍 Analysis Context
 Question: {query}
 
-Relevant code files (ordered by relevance):
+Relevant Code Files (by relevance):
 """
+
         # Add context with length control
         available_count = self.max_token_count - get_context_token_count(prompt) - 1000  # Reserve space for answer
         current_count = 0
@@ -812,10 +837,11 @@ Relevant code files (ordered by relevance):
             try:
                 content = open(path["file"], "r", encoding="utf-8").read()
                 file_content = f"""
-File: {path["file"]}
-Content:
+## File: {path["file"]}
+```
 {content}
-----------------------------------------
+```
+---
 """
                 if current_count + get_context_token_count(file_content) > available_count:
                     PrettyOutput.print(
@@ -831,17 +857,19 @@ Content:
                 PrettyOutput.print(f"读取 {path} 失败: {str(e)}", 
                                 output_type=OutputType.ERROR)
                 continue
-        
-        model = PlatformRegistry.get_global_platform_registry().get_thinking_platform()
 
         prompt += """
-Output Format:
-- question: the question to answer
-  answer: the answer to the question
-- question: the question to answer
-  answer: the answer to the question
+# ❗ Important Rules
+1. Always base answers on provided code
+2. Use technical precision
+3. Include code examples when relevant
+4. Indicate any missing information
+5. Maintain professional language
+6. Answer in user's language
 """
 
+        model = PlatformRegistry.get_global_platform_registry().get_thinking_platform()
+
         return files_from_codebase, model.chat_until_success(prompt)
 
     def is_index_generated(self) -> bool: