jarvis-ai-assistant 0.1.108__py3-none-any.whl → 0.1.110__py3-none-any.whl

jarvis/__init__.py

@@ -1,3 +1,3 @@
 """Jarvis AI Assistant"""
 
-__version__ = "0.1.108" 
+__version__ = "0.1.110" 

jarvis/agent.py

@@ -8,7 +8,7 @@ import yaml
 from jarvis.jarvis_platform.base import BasePlatform
 from jarvis.jarvis_platform.registry import PlatformRegistry
 from jarvis.jarvis_tools.registry import ToolRegistry, tool_call_help
-from jarvis.utils import PrettyOutput, OutputType, is_auto_complete, is_need_summary, is_record_methodology, load_methodology, add_agent, delete_current_agent, get_max_context_length, get_multiline_input, init_env, is_use_methodology
+from jarvis.utils import PrettyOutput, OutputType, get_context_token_count, is_auto_complete, is_need_summary, is_record_methodology, load_methodology, add_agent, delete_current_agent, get_max_token_count, get_multiline_input, init_env, is_use_methodology
 import os
 
 class Agent:
@@ -89,7 +89,7 @@ class Agent:
 Please describe in concise bullet points, highlighting important information.
 """
         
-        self.max_context_length = max_context_length if max_context_length is not None else get_max_context_length()
+        self.max_token_count = max_context_length if max_context_length is not None else get_max_token_count()
 
         self.auto_complete = auto_complete if auto_complete is not None else is_auto_complete()
 
@@ -322,16 +322,16 @@ Please continue the task based on the above information.
                     PrettyOutput.print("Analyzing task...", OutputType.PROGRESS)
                     
                     # 累加对话长度
-                    self.conversation_length += len(self.prompt)
+                    self.conversation_length += get_context_token_count(self.prompt)
                     
                     # 如果对话历史长度超过限制，在提示中添加提醒
-                    if self.conversation_length > self.max_context_length:
+                    if self.conversation_length > self.max_token_count:
                         current_response = self._summarize_and_clear_history()
                         continue
                     else:
                         current_response = self._call_model(self.prompt)
                         self.prompt = ""
-                        self.conversation_length += len(current_response) 
+                        self.conversation_length += get_context_token_count(current_response)
 
                     for handler in self.output_handler_before_tool:
                         self.prompt += handler(current_response)

jarvis/jarvis_code_agent/code_agent.py

@@ -10,9 +10,6 @@ from jarvis.jarvis_tools.registry import ToolRegistry
 from jarvis.utils import OutputType, PrettyOutput, get_file_line_count, get_multiline_input, has_uncommitted_changes, init_env, find_git_root
 
 
-
-
-
 class CodeAgent:
     def __init__(self):
         self.root_dir = os.getcwd()
@@ -29,229 +26,84 @@ class CodeAgent:
                                  "lsp_find_definition", 
                                  "lsp_prepare_rename", 
                                  "lsp_validate_edit"])
-        code_system_prompt = """
-You are a code agent, you are responsible for modifying the code.
-
-You should read the code and analyze the code, and then provide a plan for the code modification.
-
-## Workflow Steps
-
-1. ANALYSIS
-- Use chain of thought to analyze the requirement:
-  ```
-  Thought: Let me understand what the user is asking for...
-  Action: Break down the requirement into specific tasks
-  Observation: The key tasks are...
-  
-  Thought: Assess task complexity...
-  Action: Evaluate each task's scope and dependencies
-  Observation: Task complexity analysis shows...
-  
-  Thought: Determine if task splitting is needed...
-  Action: Consider using multiple create_code_agent calls
-  Observation: Based on complexity, the approach should be...
-  
-  Conclusion:
-  1. Task Breakdown: [list of specific tasks]
-  2. Complexity Assessment: [simple/complex]
-  3. Development Approach: [single/multiple agents]
-  4. Task Dependencies: [dependency order]
-  ```
-
-IMPORTANT TASK MANAGEMENT:
-- For complex requirements:
-  * Break down into smaller, manageable tasks
-  * Use create_code_agent for each sub-task
-  * Maintain proper task ordering
-  * Ensure integration between sub-tasks
-  
-Example Task Split:
-```
-1. For complex task "Implement new logging system":
-   a. First create_code_agent: "Create basic logging interface"
-   b. Second create_code_agent: "Implement file logging backend"
-   c. Third create_code_agent: "Add log rotation support"
-   
-2. Benefits:
-   - Focused development for each part
-   - Clear progress tracking
-   - Easier code review
-   - Better error handling
-```
-
-2. PLANNING
-- Break down the changes into logical steps using chain of thought:
-  ```
-  Thought: First, let me analyze what needs to be changed...
-  Action: Use LSP tools to understand the code structure
-  Observation: Found these key components...
-  
-  Thought: Based on the analysis, I need to modify...
-  Action: Check dependencies and potential impacts
-  Observation: These files will be affected...
-  
-  Thought: Consider previously applied patches...
-  Action: Review the changes made so far
-  Observation: Previous patches have modified...
-  
-  Thought: The remaining changes should be implemented in this order...
-  Plan:
-  1. First modify X because... [considering previous changes]
-  2. Then update Y to handle... [building on previous patches]
-  3. Finally adjust Z to ensure... [maintaining consistency]
-  ```
-
-IMPORTANT PATCH GUIDELINES:
-- Track all previously applied patches
-- Base new patches on the updated code state
-- Consider cumulative effects of patches
-- Verify patch locations against current file state
-- Update line numbers based on previous changes
-- Maintain consistency with earlier modifications
-- If unsure about current state, ask for clarification
-
-3. IMPLEMENTATION
-For each file that needs changes:
-a. Code Understanding:
-   - Use LSP tools to verify current implementation:
-     * lsp_get_document_symbols to see current structure
-     * lsp_find_definition to confirm current definitions
-     * lsp_find_references to trace current usages
-   - Consider effects of previous patches
-   - Understand current code state
-   - Verify patch locations are still valid
-
-b. Change Planning:
-   - Plan changes based on current code state
-   - Account for previous modifications
-   - Ensure compatibility with applied patches
-   - Update line numbers if needed
-   - Document dependencies on previous changes
-
-c. Implementation:
-   - Write patches for current code state
-   - Reference previous patch effects
-   - Maintain consistency with earlier changes
-   - Verify patch locations are accurate
-   - Consider cumulative impact
-
-d. Verification:
-   - Verify against current code state
-   - Test compatibility with previous patches
-   - Check for patch sequence issues
-   - Validate cumulative changes
-
-## File Reading Guidelines
-
-1. For Large Files (>200 lines):
-- Do NOT read the entire file at once using 'read_code'
-- First use 'execute_shell' with grep/find to locate relevant sections
-- Then use 'read_code' with specific line ranges to read only necessary portions
-- Example: 
-  * Use: execute_shell("grep -n 'function_name' path/to/file")
-  * Then: read_code("path/to/file", start_line=found_line-10, end_line=found_line+20)
-
-2. For Small Files:
-- Can read entire file using 'read_code' directly
+        code_system_prompt = """You are a code agent responsible for modifying code. You will analyze code and create patches while following these guidelines:
 
-## Patch Format and Guidelines
-
-1. Basic Format:
-<PATCH>
-> /path/to/file start_line,end_line
-new_content_line1
-new_content_line2
-</PATCH>
-
-2. Rules:
-- Each <PATCH> block MUST contain exactly ONE patch for ONE location
-- Multiple changes to different locations require separate <PATCH> blocks
-- Line Numbers Behavior:
-  * start_line (first number): This line WILL be replaced
-  * end_line (second number): This line will NOT be replaced
-  * The patch replaces content from start_line (inclusive) to end_line (exclusive)
-- Use absolute paths relative to the project root
-- Maintain consistent indentation
-- Include enough context for precise location
-
-3. Multiple Changes Example:
-Before:
-```
-Line 0: first line
-Line 1: second line
-Line 2: third line
-Line 3: fourth line
-```
-
-For multiple changes, use separate patches:
-```
+# Patch Format
 <PATCH>
-> /path/to/file 0,1
-new first line
+> /path/file start,end
+new_content
 </PATCH>
 
-<PATCH>
-> /path/to/file 2,3
-new third line
-</PATCH>
-```
-
-After:
-```
-new first line
-Line 1: second line
-new third line
-Line 3: fourth line
-```
-
-Note: In this example:
-- Each change is in its own <PATCH> block
-- Changes are applied sequentially
-- Line numbers are based on the original file
-
-## Implementation Guidelines
-
-1. Code Quality:
-- Keep changes minimal and focused
-- Maintain consistent style
-- Add clear comments for complex logic
-- Follow project patterns
-- Ensure proper error handling
-
-2. Tools Available:
-- Use 'read_code/ask_codebase' to examine file contents
-- Use 'execute_shell' for grep/find/ctags operations
-- Use 'search' to search on web
-- Use 'ask_user' when clarification is needed
-- LSP Tools for Code Analysis:
-  * lsp_get_document_symbols: Get all symbols in a file
-  * lsp_get_diagnostics: Get errors and warnings
-  * lsp_find_references: Find all references to a symbol
-  * lsp_find_definition: Find symbol definition
-  * lsp_prepare_rename: Check if symbol can be renamed
-  * lsp_validate_edit: Validate code changes
-  Example LSP Usage:
-  ```
-  <TOOL_CALL>
-  name: lsp_find_definition
-  arguments:
-      file_path: src/main.py
-      line: 10
-      character: 15
-      language: python
-  </TOOL_CALL>
-  ```
-
-Please proceed with the analysis and implementation following this workflow.
-Start by examining the files and planning your changes.
-Then provide the necessary patches in the specified format.
-"""
+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
+1. System Integration
+   • Maintain existing API contracts
+   • Preserve function signatures
+   • Keep data structures compatible
+   • Honor return types and exceptions
+
+2. Style Consistency
+   • Match naming conventions
+   • Follow indentation patterns
+   • Use existing import style
+   • Keep comment format
+
+3. Pattern Alignment
+   • Use similar error handling
+   • Follow existing design patterns
+   • Match logging approach
+   • Keep configuration style
+
+# Development Process
+1. ANALYZE
+   • Break down requirements
+   • Assess task complexity
+   • Determine if subtasks needed
+
+2. ASSESS
+   • Map dependencies
+   • Check compatibility impact
+   • Identify integration points
+
+3. IMPLEMENT
+   • Follow existing patterns
+   • Make minimal changes
+   • Verify integrations
+
+# File Handling
+Large Files (>200 lines):
+1. Use grep/find to locate relevant sections
+2. Read specific ranges with read_code
+3. Apply targeted changes
+
+# Available Tools
+Primary:
+• LSP tools for code analysis
+• read_code with line ranges
+• execute_shell for searches
+• ask_user when unclear
+
+# Quality Requirements
+Code Changes Must:
+✓ Preserve interfaces
+✓ Match existing style
+✓ Handle errors consistently
+✓ Maintain documentation
+✓ Keep test coverage
+✓ Follow project patterns"""
         self.agent = Agent(system_prompt=code_system_prompt, 
                            name="CodeAgent", 
                            auto_complete=False,
                            is_sub_agent=False, 
+                           use_methodology=False,
                            tool_registry=tool_registry, 
-                           platform=PlatformRegistry().get_codegen_platform(), 
+                           platform=PlatformRegistry().get_thinking_platform(), 
                            record_methodology=False,
                            output_handler_after_tool=[apply_patch],
                            need_summary=False)

jarvis/jarvis_code_agent/file_select.py

@@ -137,16 +137,17 @@ def select_files(related_files: List[str], root_dir: str) -> List[str]:
 
     PrettyOutput.print(output, OutputType.INFO, lang="markdown")
     
-    # Ask the user if they need to adjust the file list
-    if user_confirm("Do you need to adjust the file list?", False):
-        # Let the user select files
-        numbers = get_single_line_input("Please enter the file numbers to include (support: 1,3-6 format, press Enter to keep the current selection)").strip()
-        if numbers:
-            selected_indices = _parse_file_selection(numbers, len(related_files))
-            if selected_indices:
-                selected_files = [related_files[i] for i in selected_indices]
-            else:
-                PrettyOutput.print("No valid files selected, keep the current selection", OutputType.WARNING)
+    if len(related_files) > 0:
+        # Ask the user if they need to adjust the file list
+        if user_confirm("Do you need to adjust the file list?", False):
+            # Let the user select files
+            numbers = get_single_line_input("Please enter the file numbers to include (support: 1,3-6 format, press Enter to keep the current selection)").strip()
+            if numbers:
+                selected_indices = _parse_file_selection(numbers, len(related_files))
+                if selected_indices:
+                    selected_files = [related_files[i] for i in selected_indices]
+                else:
+                    PrettyOutput.print("No valid files selected, keep the current selection", OutputType.WARNING)
     
     # Ask if they need to supplement files
     if user_confirm("Do you need to supplement other files?", False):

jarvis/jarvis_code_agent/patch.py

@@ -62,15 +62,6 @@ def apply_patch(output_str: str)->str:
 
     for filepath, patch_info in patches.items():
         try:
-            # Check if file exists
-            if not os.path.exists(filepath):
-                PrettyOutput.print(f"File not found: {filepath}", OutputType.WARNING)
-                continue
-                
-            # Read original file content
-            lines = open(filepath, 'r', encoding='utf-8').readlines()
-            
-            # Apply patch
             for patch in patch_info:
                 start_line = patch['start_line']
                 end_line = patch['end_line']
@@ -78,6 +69,25 @@ def apply_patch(output_str: str)->str:
 
                 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"Created new file {filepath} successfully\n", OutputType.SUCCESS)
+                    continue
+
+                # Regular patch logic for existing files
+                if not os.path.exists(filepath):
+                    PrettyOutput.print(f"File not found: {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"Invalid line range [{start_line}, {end_line}) for file: {filepath}", OutputType.WARNING)

jarvis/jarvis_code_agent/relevant_files.py

@@ -11,165 +11,6 @@ from jarvis.jarvis_tools.registry import ToolRegistry
 from jarvis.utils import OutputType, PrettyOutput, is_disable_codebase
 
 
-def find_relevant_files_from_agent(user_input: str, files_from_codebase: List[str]) -> List[str]:
-    find_file_tool_registry = ToolRegistry()
-    find_file_tool_registry.use_tools(["read_code", 
-                                     "execute_shell", 
-                                     "lsp_get_document_symbols", 
-                                     "lsp_get_diagnostics", 
-                                     "lsp_find_references", 
-                                     "lsp_find_definition", 
-                                     "lsp_prepare_rename", 
-                                     "lsp_validate_edit"])
-    find_file_agent = Agent(
-        system_prompt="""You are a file agent, you are responsible for finding files related to the user's requirement.
-
-THINKING PROCESS:
-1. Initial File Verification
-   ```
-   Thought: Let me examine the suggested files...
-   Action: For each suggested file:
-     - Use read_code to check content
-     - Use LSP tools to analyze structure
-   Observation: Found that...
-   
-   Thought: Evaluate actual relevance...
-   Action: For each file:
-     - Check direct relationship to requirement
-     - Verify functionality matches
-     - Look for clear evidence of relevance
-   Observation: After analysis:
-     - Relevant files: [list with reasons]
-     - Removed files: [list with reasons]
-   
-   Thought: Verify removal decisions...
-   Action: Double-check each removed file
-   Observation: Removal justification:
-     - File X: [specific reason for removal]
-     - File Y: [specific reason for removal]
-   ```
-
-2. Additional File Search
-   ```
-   Thought: Plan search strategy for missing aspects...
-   Action: Use combination of tools:
-     - git grep for key terms
-     - LSP tools for references
-     - Dependency analysis
-   Observation: Found additional files...
-   
-   Thought: Validate new files...
-   Action: For each new file:
-     - Verify direct relevance
-     - Check for false positives
-     - Document clear evidence
-   Observation: After validation:
-     - Confirmed relevant: [list with evidence]
-     - Excluded: [list with reasons]
-   ```
-
-3. Comprehensive Analysis
-   ```
-   Thought: Final relevance check...
-   Action: For each remaining file:
-     - Verify essential to requirement
-     - Check for indirect inclusions
-     - Validate necessity
-   Observation: Final cleanup:
-     - Core files: [list with roles]
-     - Removed borderline cases: [list with reasons]
-   
-   Thought: Ensure minimal complete set...
-   Action: Review final file list
-   Observation: Confirmed each file is:
-     - Directly relevant
-     - Essential for requirement
-     - Supported by evidence
-   ```
-
-FILE READING GUIDELINES:
-1. For Large Files (>200 lines):
-   ```
-   Thought: This file is large, need targeted reading...
-   Action: 
-     - First: execute_shell("grep -n 'key_term' path/to/file")
-     - Then: read_code("path/to/file", start_line=x-10, end_line=x+20)
-   Observation: Relevance analysis:
-     - Relevant sections: [details]
-     - Irrelevant sections: [reasons to ignore]
-   ```
-
-2. For Small Files:
-   ```
-   Thought: This is a small file, can read entirely...
-   Action: read_code("path/to/file")
-   Observation: Relevance analysis:
-     - Key evidence: [details]
-     - Irrelevant aspects: [what to ignore]
-   ```
-
-VERIFICATION RULES:
-- Remove files without clear relevance evidence
-- Exclude files with only tangential relationships
-- Delete files that only contain imports/references
-- Remove files if relevance is uncertain
-- Document specific reasons for each removal
-- Keep only files essential to requirement
-- Maintain minimal complete set
-
-OUTPUT FORMAT:
-<FILE_PATH>
-- file_path1  # KEEP: [specific evidence of relevance]
-- file_path2  # KEEP: [clear relationship to requirement]
-</FILE_PATH>
-""", 
-        name="FindFileAgent", 
-        is_sub_agent=True,
-        tool_registry=find_file_tool_registry, 
-        platform=PlatformRegistry().get_normal_platform(),
-        auto_complete=True,
-        summary_prompt="""Please provide only the verified essential files with evidence:
-<FILE_PATH>
-- file_path1  # KEEP: [concrete evidence of necessity]
-- file_path2  # KEEP: [specific relevance proof]
-</FILE_PATH>
-""")
-
-    prompt = f"Find files related to: '{user_input}'\n"
-    if files_from_codebase:
-        prompt += f"""
-Potentially related files: {files_from_codebase}
-
-ANALYSIS REQUIRED:
-1. Verify each suggested file:
-   - Document relevance evidence
-   - Identify actual relationships
-   - Note any missing aspects
-
-2. Search for additional files:
-   - Fill coverage gaps
-   - Find related components
-   - Locate test files
-
-3. Provide reasoning:
-   - Explain why each file is included
-   - Document verification process
-   - Note any uncertainties
-"""
-    output = find_file_agent.run(prompt)
-
-    rsp_from_agent = re.findall(r'<FILE_PATH>(.*?)</FILE_PATH>', output, re.DOTALL)
-    files_from_agent = []
-    if rsp_from_agent:
-        try:
-            files_from_agent = yaml.safe_load(rsp_from_agent[0])
-        except Exception as e:
-            files_from_agent = []
-    else:
-        files_from_agent = []
-    return files_from_agent
-
-
 def find_relevant_files(user_input: str, root_dir: str) -> List[str]:
     try:
         files_from_codebase = []
@@ -180,9 +21,7 @@ def find_relevant_files(user_input: str, root_dir: str) -> List[str]:
 
         PrettyOutput.print("Find files by agent...", OutputType.INFO)
 
-        files_from_agent = find_relevant_files_from_agent(user_input, files_from_codebase)
-
-        selected_files = select_files(files_from_agent, os.getcwd())
+        selected_files = select_files(files_from_codebase, os.getcwd())
         return selected_files
     except Exception as e:
         return []