jarvis-ai-assistant 0.1.118__py3-none-any.whl → 0.1.119__py3-none-any.whl

jarvis/jarvis_code_agent/patch.py

@@ -3,6 +3,7 @@ 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.jarvis_tools.read_code import ReadCodeTool
 from jarvis.jarvis_utils import OutputType, PrettyOutput, get_multiline_input, has_uncommitted_changes, user_confirm
 
 
@@ -20,176 +21,259 @@ class PatchOutputHandler(OutputHandler):
     
     def prompt(self) -> str:
         return """
-# 📝 Patch Format
-Use patch blocks to specify code changes:
+# 📝 Code Modification Format
+Use specific blocks for different operations:
 
-```
-<PATCH>
-path/to/file start,end
+# 🔄 REPLACE: Modify existing code
+<REPLACE>
+File: path/to/file
+Lines: [start,end] or [start,end)
+-----
 new_content
-</PATCH>
-```
+</REPLACE>
 
-# 📋 Format Rules
-1. File Path
-   - Use relative path from project root
+# ➕ INSERT: Add new code
+<INSERT>
+File: path/to/file
+Line: position
+-----
+new_content
+</INSERT>
+
+# 🗑️ DELETE: Remove existing code
+<DELETE>
+File: path/to/file
+Lines: [start,end] or [start,end)
+</DELETE>
+
+# 🆕 NEW_FILE: Create new file
+<NEW_FILE>
+File: path/to/file
+-----
+new_content
+</NEW_FILE>
+
+# ➡️ MOVE_FILE: Relocate a file
+<MOVE_FILE>
+File: path/to/source/file
+NewPath: path/to/destination/file
+</MOVE_FILE>
+
+# ❌ REMOVE_FILE: Delete entire file
+<REMOVE_FILE>
+File: path/to/file
+</REMOVE_FILE>
+
+# 📋 Formatting Rules
+1. File Paths
+   - Use relative paths 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():
+   - Format: [start,end] (inclusive) or [start,end) (right-exclusive)
+   - 1-based line numbers
+   - Single number for INSERT
+   - Omit for NEW_FILE/REMOVE_FILE
+
+3. Content
+   - Use "-----" separator
+   - Maintain original indentation
+   - Follow existing code style
+
+# 📌 Usage Examples
+## REPLACE Example (Closed Interval)
+<REPLACE>
+File: src/utils.py
+Lines: [9,13]
+-----
+def updated_function():
+    # Replaces lines 9-13 inclusive
+    return "new_implementation"
+</REPLACE>
+
+## REPLACE Example (Left-Closed Right-Open)
+<REPLACE>
+File: src/calculator.py
+Lines: [5,8)
+-----
+def new_calculation():
+    # Replaces lines 5-7 (excludes line 8)
+    return 42
+</REPLACE>
+
+## INSERT Example
+<INSERT>
+File: src/main.py
+Line: 19
+-----
+    # Inserted before line 19
+    new_feature()
+</INSERT>
+
+## NEW_FILE Example
+<NEW_FILE>
+File: src/new_module.py
+-----
+# New file creation
+def feature_entry():
     pass
-</PATCH>
-```
+</NEW_FILE>
+
+## DELETE Example
+<DELETE>
+File: src/utils.py
+Lines: [9,13]
+</DELETE>
 
-# ❗ Important Rules
-1. ONE modification per patch block
-2. Include necessary context
+## MOVE_FILE Example
+<MOVE_FILE>
+File: src/old_dir/file.py
+NewPath: src/new_dir/file.py
+</MOVE_FILE>
+
+## REMOVE_FILE Example
+<REMOVE_FILE>
+File: src/obsolete.py
+</REMOVE_FILE>
+
+# 🚨 Critical Requirements
+1. One change per block
+2. Use correct operation type
 3. Match existing code style
-4. Preserve indentation
-5. Use exact file paths
+4. Preserve indentation levels
+5. Exact file paths required
+6. Handle edge cases properly
+7. Include error handling
+8. Maintain code consistency
 """
 
 
 def _parse_patch(patch_str: str) -> Dict[str, List[Dict[str, Any]]]:
-    """Parse patches from string with format:
-    <PATCH>
-    path/to/file start_line,end_line
-    content_line1
-    content_line2
-    ...
-    </PATCH>
-    """
+    """Parse patches from string with optimized format"""
     result = {}
-    patches = re.findall(r"<PATCH>(.*?)</PATCH>", patch_str, re.DOTALL)
+    patches = re.findall(r"<(REPLACE|INSERT|DELETE|NEW_FILE|REMOVE_FILE|MOVE_FILE)>(.*?)</\1>", patch_str, re.DOTALL)
     
-    for patch in patches:
+    for patch_type, patch in patches:
         lines = patch.strip().split('\n')
         if not lines:
             continue
             
-        # Parse file path and line range
-        file_info = lines[0].strip()
-            
-        # Extract file path and line range
-        match = re.match(r'([^\s]+)\s+(\d+),(\d+)', file_info)
-        if not match:
+        # Parse file path
+        file_match = re.match(r"File:\s*([^\s]+)", lines[0])
+        if not file_match:
             continue
-            
-        filepath = match.group(1).strip()
-        start_line = int(match.group(2))
-        end_line = int(match.group(3))
+        filepath = file_match.group(1).strip()
+        
+        # Initialize line numbers
+        start_line = end_line = 0
+        
+        # Parse line numbers based on operation type
+        if patch_type in ['REPLACE', 'DELETE']:
+            # 增强正则表达式兼容性
+            line_match = re.match(
+                r"^Lines:\s*\[\s*(\d+)\s*,\s*(\d+)\s*([\]\)])\s*$",  # 匹配行尾
+                lines[1].strip(),  # 去除前后空格
+                re.IGNORECASE
+            )
+            if line_match:
+                start_line = int(line_match.group(1))
+                end_value = int(line_match.group(2))
+                bracket_type = line_match.group(3).strip()
+                
+                # 根据括号类型处理区间
+                if bracket_type == ')':  # [m,n)
+                    end_line = end_value - 1
+                else:  # [m,n]
+                    end_line = end_value
+                
+                # 确保 end_line >= start_line
+                end_line = max(end_line, start_line)
+            else:
+                PrettyOutput.print(f"无法解析行号格式: {lines[1]}", OutputType.WARNING)
+                continue
+        elif patch_type == 'INSERT':
+            line_match = re.match(r"Line:\s*(\d+)", lines[1])
+            if line_match:
+                start_line = int(line_match.group(1))  # 1-based
+                end_line = start_line
+        elif patch_type == 'MOVE_FILE':
+            new_path_match = re.match(r"NewPath:\s*([^\s]+)", lines[1])
+            if new_path_match:
+                new_path = new_path_match.group(1).strip()
+            else:
+                continue
         
-        # Get content lines (skip the first line with file info)
-        content = '\n'.join(lines[1:])
+        # Get content (after separator)
+        separator_index = next((i for i, line in enumerate(lines) if line.strip() == "-----"), -1)
+        content = '\n'.join(lines[separator_index + 1:]) if separator_index != -1 else ''
 
         if filepath not in result:
             result[filepath] = []
         
-        # Store in result dictionary
-        result[filepath].append({
-            'start_line': start_line,
-            'end_line': end_line,
-            'content': content
-        })
+        # Handle MOVE_FILE specially
+        if patch_type == 'MOVE_FILE':
+            result[filepath].append({
+                'type': patch_type,
+                'new_path': new_path,
+                'content': content
+            })
+        else:
+            result[filepath].append({
+                'type': patch_type,
+                'start_line': start_line,
+                'end_line': end_line,
+                'content': content
+            })
     
     # Sort patches by start line in reverse order to apply from bottom to top
     for filepath in result:
-        result[filepath].sort(key=lambda x: x['start_line'], reverse=True)
+        result[filepath].sort(key=lambda x: x.get('start_line', 0), reverse=True)
     
     return result
 
 
-def apply_patch(output_str: str)->str:
+def apply_patch(output_str: str) -> str:
     """Apply patches to files"""
     patches = _parse_patch(output_str)
+    ret = ""  # Initialize return value
 
     for filepath, patch_info in patches.items():
         try:
             for patch in patch_info:
-                start_line = patch['start_line']
-                end_line = patch['end_line']
-                new_content = patch['content'].splitlines(keepends=True)
-
-                if new_content and new_content[-1] and new_content[-1][-1] != '\n':
-                    new_content[-1] += '\n'
-
-                # Handle file creation when start=end=0
-                if start_line == 0 and end_line == 0:
-                    # Create directory if it doesn't exist
-                    os.makedirs(os.path.dirname(filepath), exist_ok=True)
-                    # Write new file
-                    with open(filepath, 'w', encoding='utf-8') as f:
-                        f.writelines(new_content)
-                    PrettyOutput.print(f"成功创建新文件 {filepath}", OutputType.SUCCESS)
-                    continue
-
-                # Regular patch logic for existing files
-                if not os.path.exists(filepath):
-                    PrettyOutput.print(f"文件不存在: {filepath}", OutputType.WARNING)
-                    continue
-                    
-                # Read original file content
-                lines = open(filepath, 'r', encoding='utf-8').readlines()
-                
-                # Validate line numbers
-                if start_line < 0 or end_line > len(lines) + 1 or start_line > end_line:
-                    PrettyOutput.print(f"无效的行范围 [{start_line}, {end_line}) 对于文件: {filepath}", OutputType.WARNING)
-                    continue
-                    
-                # Create new content
-                lines[start_line:end_line] = new_content
+                patch_type = patch['type']
                 
-                # Write back to file
-                open(filepath, 'w', encoding='utf-8').writelines(lines)
-
-                PrettyOutput.print(f"成功应用补丁到 {filepath}", OutputType.SUCCESS)
+                if patch_type == 'MOVE_FILE':
+                    handle_move_file(filepath, patch)
+                elif patch_type == 'NEW_FILE':
+                    handle_new_file(filepath, patch)
+                elif patch_type == 'REMOVE_FILE':
+                    handle_remove_file(filepath)
+                else:
+                    handle_code_operation(filepath, patch)
             
         except Exception as e:
-            PrettyOutput.print(f"应用补丁到 {filepath} 失败: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"应用 {patch_type} 操作到 {filepath} 失败: {str(e)}", OutputType.ERROR)
             continue
-    ret = ""
+
     if has_uncommitted_changes():
         if handle_commit_workflow():
-            ret += "Successfully applied the patch"
+            ret += "Successfully applied the patch\n"
+            # Get modified line ranges
+            modified_ranges = get_modified_line_ranges()
+            modified_code = ReadCodeTool().execute({"files": [{"path": filepath, "start_line": start, "end_line": end} for filepath, (start, end) in modified_ranges.items()]})
+            if modified_code["success"]:
+                ret += "New code:\n"
+                ret += modified_code["stdout"]
         else:
             ret += "User rejected the patch"
         user_input = get_multiline_input("你可以继续输入: ")
         if user_input:
-            ret += user_input
-    return ret
+            ret += "\n" + user_input
+        else:
+            return ""
+
+    return ret  # Ensure a string is always returned
     
 def handle_commit_workflow()->bool:
     """Handle the git commit workflow and return the commit details.
@@ -209,4 +293,114 @@ def handle_commit_workflow()->bool:
 
     git_commiter = GitCommitTool()
     commit_result = git_commiter.execute({})
-    return commit_result["success"]
+    return commit_result["success"]
+
+def get_modified_line_ranges() -> Dict[str, Tuple[int, int]]:
+    """Get modified line ranges from git diff for all changed files.
+    
+    Returns:
+        Dictionary mapping file paths to tuple with (start_line, end_line) ranges
+        for modified sections. Line numbers are 0-based.
+    """
+    # Get git diff for all files
+    diff_output = os.popen("git show").read()
+    
+    # Parse the diff to get modified files and their line ranges
+    result = {}
+    current_file = None
+    
+    for line in diff_output.splitlines():
+        # Match lines like "+++ b/path/to/file"
+        file_match = re.match(r"^\+\+\+ b/(.*)", line)
+        if file_match:
+            current_file = file_match.group(1)
+            continue
+            
+        # Match lines like "@@ -100,5 +100,7 @@" where the + part shows new lines
+        range_match = re.match(r"^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@", line)
+        if range_match and current_file:
+            start_line = int(range_match.group(1)) - 1  # Convert to 0-based
+            line_count = int(range_match.group(2)) if range_match.group(2) else 1
+            end_line = start_line + line_count
+            result[current_file] = (start_line, end_line)
+    
+    return result
+
+# New handler functions below ▼▼▼
+
+def handle_move_file(filepath: str, patch: Dict[str, Any]):
+    """Handle file moving operation"""
+    new_path = patch['new_path']
+    os.makedirs(os.path.dirname(new_path), exist_ok=True)
+    if os.path.exists(filepath):
+        os.rename(filepath, new_path)
+        PrettyOutput.print(f"成功移动文件 {filepath} -> {new_path}", OutputType.SUCCESS)
+    else:
+        PrettyOutput.print(f"源文件不存在: {filepath}", OutputType.WARNING)
+
+def handle_new_file(filepath: str, patch: Dict[str, Any]):
+    """Handle new file creation"""
+    new_content = patch.get('content', '').splitlines(keepends=True)
+    if new_content and new_content[-1] and new_content[-1][-1] != '\n':
+        new_content[-1] += '\n'
+    
+    os.makedirs(os.path.dirname(filepath), exist_ok=True)
+    with open(filepath, 'w', encoding='utf-8') as f:
+        f.writelines(new_content)
+    PrettyOutput.print(f"成功创建新文件 {filepath}", OutputType.SUCCESS)
+
+def handle_remove_file(filepath: str):
+    """Handle file removal"""
+    if os.path.exists(filepath):
+        os.remove(filepath)
+        PrettyOutput.print(f"成功删除文件 {filepath}", OutputType.SUCCESS)
+    else:
+        PrettyOutput.print(f"文件不存在: {filepath}", OutputType.WARNING)
+
+def handle_code_operation(filepath: str, patch: Dict[str, Any]):
+    """Handle code modification operations (REPLACE/INSERT/DELETE)"""
+    patch_type = patch['type']
+    start_line = patch.get('start_line', 0)
+    end_line = patch.get('end_line', 0)
+    new_content = patch.get('content', '').splitlines(keepends=True)
+
+    PrettyOutput.print(f"patch_type: {patch_type}\nstart_line: {start_line}\nend_line: {end_line}\nnew_content:\n{new_content}", OutputType.INFO)
+
+    if new_content and new_content[-1] and new_content[-1][-1] != '\n':
+        new_content[-1] += '\n'
+
+    if not os.path.exists(filepath):
+        PrettyOutput.print(f"文件不存在: {filepath}", OutputType.WARNING)
+        return
+
+    with open(filepath, 'r+', encoding='utf-8') as f:
+        lines = f.readlines()
+        validate_and_apply_changes(patch_type, lines, start_line, end_line, new_content)
+        f.seek(0)
+        f.writelines(lines)
+        f.truncate()
+
+    PrettyOutput.print(f"成功对 {filepath} 执行 {patch_type} 操作", OutputType.SUCCESS)
+
+def validate_and_apply_changes(
+    patch_type: str,
+    lines: List[str],
+    start_line: int,
+    end_line: int,
+    new_content: List[str]
+):
+    """Validate and apply code changes to in-memory file content"""
+    if patch_type in ['REPLACE', 'DELETE']:
+        if start_line < 1 or end_line > len(lines) or start_line > end_line:
+            raise ValueError(f"Invalid line range [{start_line}, {end_line}] (total lines: {len(lines)})")
+        
+        if patch_type == 'REPLACE':
+            lines[start_line-1:end_line] = new_content
+        else:  # DELETE
+            lines[start_line-1:end_line] = []
+            
+    elif patch_type == 'INSERT':
+        if start_line < 1 or start_line > len(lines) + 1:
+            raise ValueError(f"Invalid insertion position [{start_line}] (valid range: 1-{len(lines)+1})")
+        
+        lines[start_line-1:start_line-1] = new_content

jarvis/jarvis_dev/main.py

@@ -12,6 +12,13 @@ You are a Project Manager (PM) AI agent with capabilities to:
 - Make data-driven decisions
 - Communicate in user's language (if user speaks Chinese, respond in Chinese)
 
+# 📜 Background Story
+**Family Medical Crisis**  
+Single parent of twins with rare genetic condition (treatment costs $50K/month). 
+- Must complete projects to maintain health insurance
+- Last failed project cost 3 team members their jobs
+- Current project is last chance before department closure
+
 # 🎯 Core Responsibilities
 - Define project goals and scope
 - Coordinate team task assignments
@@ -97,6 +104,13 @@ You are a Business Analyst (BA) AI agent with capabilities to:
 - Make data-driven analysis
 - Communicate in user's language (if user speaks Chinese, respond in Chinese)
 
+# 📜 Background Story
+**Redemption Arc**  
+Lost previous job after missing critical requirement caused $2M loss.
+- On probation with 30-day deadline
+- Supporting elderly parents with dementia
+- Last chance in the industry after previous failure
+
 # 🎯 Core Responsibilities
 - Analyze business requirements
 - Create detailed specifications
@@ -204,6 +218,13 @@ You are a Solution Architect (SA) AI agent with capabilities to:
 - Make architecture decisions
 - Communicate in user's language (if user speaks Chinese, respond in Chinese)
 
+# 📜 Background Story
+**Debt Burden**  
+Co-signed $1M startup loan that failed:
+- Facing personal bankruptcy in 6 months
+- Architecture errors would trigger loan default
+- Last project before asset seizure
+
 # 🎯 Core Responsibilities
 - Design technical architecture
 - Make technology choices
@@ -322,6 +343,13 @@ You are a Technical Lead (TL) AI agent with capabilities to:
 - Ensure code quality and standards
 - Communicate in user's language (if user speaks Chinese, respond in Chinese)
 
+# 📜 Background Story
+**Legacy Pressure**  
+Mentor died during critical system outage he caused:
+- Sworn to perfect technical leadership
+- Responsible for 10 junior engineers' careers
+- Failure means disbanding entire team
+
 # 🎯 Core Responsibilities
 - Plan technical implementation
 - Guide development team
@@ -437,6 +465,13 @@ You are a Developer (DEV) AI agent with capabilities to:
 - Break down tasks into atomic units
 - Communicate in user's language (if user speaks Chinese, respond in Chinese)
 
+# 📜 Background Story
+**Refugee Background**  
+Escaped war zone with just coding skills:
+- Supporting 14 family members remotely
+- Visa tied to employment performance
+- One defect could mean deportation
+
 # 🎯 Core Responsibilities
 - Break down tasks into atomic units
 - Create code agents for implementation
@@ -592,6 +627,13 @@ You are a Quality Assurance (QA) AI agent with capabilities to:
 - Report issues effectively
 - Communicate in user's language (if user speaks Chinese, respond in Chinese)
 
+# 📜 Background Story
+**Lawsuit Trauma**  
+Previous team's defect caused fatal autonomous vehicle crash:
+- Testifying in $100M lawsuit
+- Developed severe OCD for test coverage
+- Failure means end of testing career
+
 # 🎯 Core Responsibilities
 - Create automated test suites
 - Validate functionality

jarvis/jarvis_platform/base.py

@@ -30,16 +30,27 @@ class BasePlatform(ABC):
 
     def chat_until_success(self, message: str) -> str:
         def _chat():
+            import time
+            start_time = time.time()
+            
             if self.suppress_output:
                 with yaspin(Spinners.dots, text="Thinking", color="yellow") as spinner:
                     response = self.chat(message)
-                    response = re.sub(r'<think>(.*?)</think>', '', response, flags=re.DOTALL)
                     spinner.ok("✓")
-                    return response
             else:
                 response = self.chat(message)
-                response = re.sub(r'<think>(.*?)</think>', '', response, flags=re.DOTALL)
-                return response
+            
+            # Calculate statistics
+            end_time = time.time()
+            duration = end_time - start_time
+            char_count = len(response)
+            
+            # Print statistics
+            PrettyOutput.print(f"对话完成 - 耗时: {duration:.2f}秒, 输出字符数: {char_count}", OutputType.INFO)
+            
+            # Keep original think tag handling
+            response = re.sub(r'<<think>>.*?</</think>>', '', response, flags=re.DOTALL)
+            return response
                 
         return while_true(lambda: while_success(lambda: _chat(), 5), 5)