jarvis-ai-assistant 0.1.104__py3-none-any.whl → 0.1.105__py3-none-any.whl

jarvis/__init__.py

@@ -1,3 +1,3 @@
 """Jarvis AI Assistant"""
 
-__version__ = "0.1.104" 
+__version__ = "0.1.105" 

jarvis/agent.py

@@ -5,22 +5,29 @@ from typing import Callable, Dict, List, Optional
 from prompt_toolkit import prompt
 import yaml
 
-from jarvis.models.base import BasePlatform
-from jarvis.models.registry import PlatformRegistry
-from jarvis.tools.registry import ToolRegistry, tool_call_help
-from jarvis.utils import PrettyOutput, OutputType, is_auto_complete, load_methodology, add_agent, delete_current_agent, get_max_context_length, get_multiline_input, init_env
+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
 import os
 
 class Agent:
 
-    def __del__(self):
-        delete_current_agent()
-
     def set_summary_prompt(self, summary_prompt: str):
+        """Set the summary prompt for task completion.
+        
+        Args:
+            summary_prompt: The prompt template for generating task summaries
+        """
         self.summary_prompt = summary_prompt
 
-    def set_output_filter(self, output_filter: List[Callable]):
-        self.output_filter = output_filter
+    def set_output_handler_before_tool(self, handler: List[Callable]):
+        """Set handlers to process output before tool execution.
+        
+        Args:
+            handler: List of callable functions to process output
+        """
+        self.output_handler_before_tool = handler
         
     def __init__(self, 
                  system_prompt: str, 
@@ -29,35 +36,47 @@ class Agent:
                  tool_registry: Optional[ToolRegistry] = None, 
                  platform: Optional[BasePlatform] = None, 
                  summary_prompt: Optional[str] = None, 
-                 auto_complete: bool = False, 
-                 record_methodology: bool = True,
-                 output_filter: Optional[List[Callable]] = None,
-                 need_summary: bool = True):
-        """Initialize Agent with a model, optional tool registry and name
+                 auto_complete: Optional[bool] = None, 
+                 output_handler_before_tool: Optional[List[Callable]] = None,
+                 output_handler_after_tool: Optional[List[Callable]] = None,
+                 use_methodology: Optional[bool] = None,
+                 record_methodology: Optional[bool] = None,
+                 need_summary: Optional[bool] = None,
+                 max_context_length: Optional[int] = None):
+        """Initialize an Agent instance.
         
         Args:
-            system_prompt: System prompt
-            name: Agent name, default is "Jarvis"
-            is_sub_agent: Whether it is a sub-agent, default is False
-            tool_registry: Tool registry instance
-            platform: Optional platform instance, default uses normal platform
+            system_prompt: The system prompt defining agent behavior
+            name: Agent name, defaults to "Jarvis"
+            is_sub_agent: Whether this is a sub-agent
+            tool_registry: Registry of available tools
+            platform: AI platform to use
+            summary_prompt: Template for generating summaries
+            auto_complete: Whether to enable auto-completion
+            output_handler_before_tool: Handlers to process output before tool execution
+            output_handler_after_tool: Handlers to process output after tool execution
+            use_methodology: Whether to use methodology
+            record_methodology: Whether to record methodology
+            need_summary: Whether to generate summaries
+            max_context_length: Maximum context length
         """
-        add_agent(name)
         PrettyOutput.print(f"Welcome to Jarvis, your AI assistant, Initiating...", OutputType.SYSTEM)
         if platform is not None:
             self.model = platform
         else:
             self.model = PlatformRegistry.get_global_platform_registry().get_normal_platform()
         self.tool_registry = tool_registry if tool_registry else ToolRegistry()
-        self.record_methodology = record_methodology
+        self.record_methodology = record_methodology if record_methodology is not None else is_record_methodology()
+        self.use_methodology = use_methodology if use_methodology is not None else is_use_methodology()
         self.name = name
         self.is_sub_agent = is_sub_agent
         self.prompt = ""
         self.conversation_length = 0  # Use length counter instead
         self.system_prompt = system_prompt
-        self.need_summary = need_summary
+        self.need_summary = need_summary if need_summary is not None else is_need_summary()
         # Load configuration from environment variables
-        self.output_filter = output_filter if output_filter else []
+        self.output_handler_before_tool = output_handler_before_tool if output_handler_before_tool else []
+        self.output_handler_after_tool = output_handler_after_tool if output_handler_after_tool else []
 
         self.summary_prompt = summary_prompt if summary_prompt else f"""Please generate a concise summary report of the task execution, including:
 
@@ -70,28 +89,22 @@ class Agent:
 Please describe in concise bullet points, highlighting important information.
 """
         
-        self.max_context_length = get_max_context_length()
-
-        self.auto_complete = auto_complete
-
+        self.max_context_length = max_context_length if max_context_length is not None else get_max_context_length()
 
-        
-            
-        # Initialize methodology related attributes
-        self.methodology_data = []
+        self.auto_complete = auto_complete if auto_complete is not None else is_auto_complete()
 
         PrettyOutput.section(f"Jarvis initialized - With {self.model.name()}", OutputType.SYSTEM)
+
         tools = self.tool_registry.get_all_tools()
         if tools:
             PrettyOutput.section(f"Available tools: {', '.join([tool['name'] for tool in tools])}", OutputType.SYSTEM)
 
-
-        # Load methodology
         
         tools_prompt = self.tool_registry.load_tools()
         complete_prompt = """"""
         if self.auto_complete:
             complete_prompt = """
+            ## Task Completion
             When the task is completed, you should print the following message:
             <!!!COMPLETE!!!>
             """
@@ -106,8 +119,18 @@ Please describe in concise bullet points, highlighting important information.
         self.first = True
 
     @staticmethod
-    def extract_tool_calls(content: str) -> List[Dict]:
-        """Extract tool calls from content, if multiple tool calls are detected, raise an exception, and return the content before the tool call and the tool call"""
+    def _extract_tool_calls(content: str) -> List[Dict]:
+        """Extract tool calls from content.
+        
+        Args:
+            content: The content containing tool calls
+            
+        Returns:
+            List[Dict]: List of extracted tool calls with name and arguments
+            
+        Raises:
+            Exception: If tool call is missing necessary fields
+        """
         # Split content into lines
         lines = content.split('\n')
         tool_call_lines = []
@@ -143,7 +166,17 @@ Please describe in concise bullet points, highlighting important information.
         return []
 
     def _call_model(self, message: str) -> str:
-        """Call model to get response"""
+        """Call the AI model with retry logic.
+        
+        Args:
+            message: The input message for the model
+            
+        Returns:
+            str: Model's response
+            
+        Note:
+            Will retry with exponential backoff up to 30 seconds between retries
+        """
         sleep_time = 5
         while True:
             ret = self.model.chat_until_success(message)
@@ -159,16 +192,17 @@ Please describe in concise bullet points, highlighting important information.
 
 
     def _summarize_and_clear_history(self) -> None:
-        """
-        [System message]
-        Summarize current conversation history and clear history, only keep system message and summary
+        """Summarize current conversation and clear history.
         
         This method will:
-        1. Request the model to summarize the key information from the current conversation
+        1. Generate a summary of key information
         2. Clear the conversation history
         3. Keep the system message
-        4. Add the summary as new context
-        5. Reset the conversation round
+        4. Add summary as new context
+        5. Reset conversation length
+        
+        Note:
+            Used when context length exceeds maximum
         """
         # Create a new model instance to summarize, avoid affecting the main conversation
 
@@ -203,10 +237,14 @@ Please continue the task based on the above information.
             PrettyOutput.print(f"Failed to summarize conversation history: {str(e)}", OutputType.ERROR)
 
     def _complete_task(self) -> str:
-        """Complete task and generate summary
+        """Complete the current task and generate summary if needed.
         
         Returns:
             str: Task summary or completion status
+            
+        Note:
+            - For main agent: May generate methodology if enabled
+            - For sub-agent: May generate summary if enabled
         """
         PrettyOutput.section("Task completed", OutputType.SUCCESS)
         
@@ -227,7 +265,7 @@ Please continue the task based on the above information.
                     
                     # 检查是否包含工具调用
                     try:
-                        tool_calls = Agent.extract_tool_calls(response)
+                        tool_calls = Agent._extract_tool_calls(response)
                         if tool_calls:
                             self.tool_registry.handle_tool_calls(tool_calls)
                     except Exception as e:
@@ -246,17 +284,23 @@ Please continue the task based on the above information.
 
 
     def run(self, user_input: str, file_list: Optional[List[str]] = None) -> str:
-        """Process user input and return response, return task summary report
+        """Process user input and execute the task.
         
         Args:
-            user_input: User input task description
-            file_list: Optional file list, default is None
-        
+            user_input: User's task description or request
+            file_list: Optional list of files to process
+            
         Returns:
             str: Task summary report
+            
+        Note:
+            - Handles context management
+            - Processes tool calls
+            - Manages conversation flow
+            - Supports interactive mode
         """
 
-        
+        add_agent(self.name)
 
         try:
             PrettyOutput.section("Preparing environment", OutputType.PLANNING)
@@ -266,7 +310,7 @@ Please continue the task based on the above information.
             # 显示任务开始
             PrettyOutput.section(f"Starting new task: {self.name}", OutputType.PLANNING)
 
-            if self.first:
+            if self.first and self.use_methodology:
                 self.prompt = f"{user_input}\n\n{load_methodology(user_input)}"
                 self.first = False
             else:
@@ -289,11 +333,11 @@ Please continue the task based on the above information.
                         self.prompt = ""
                         self.conversation_length += len(current_response) 
 
-                    for filter in self.output_filter:
-                        self.prompt += filter(current_response)
+                    for handler in self.output_handler_before_tool:
+                        self.prompt += handler(current_response)
 
                     try:
-                        result = Agent.extract_tool_calls(current_response)
+                        result = Agent._extract_tool_calls(current_response)
                     except Exception as e:
                         PrettyOutput.print(f"Tool call error: {str(e)}", OutputType.ERROR)
                         self.prompt += f"Tool call error: {str(e)}"
@@ -303,6 +347,9 @@ Please continue the task based on the above information.
                         PrettyOutput.print("Executing tool call...", OutputType.PROGRESS)
                         tool_result = self.tool_registry.handle_tool_calls(result)
                         self.prompt += tool_result
+
+                    for handler in self.output_handler_after_tool:
+                        self.prompt += handler(current_response)
                     
                     if self.prompt:
                         continue
@@ -328,9 +375,17 @@ Please continue the task based on the above information.
             PrettyOutput.print(str(e), OutputType.ERROR)
             return f"Task failed: {str(e)}"
         
+        finally:
+            delete_current_agent()
 
-    def clear_history(self):
-        """Clear conversation history, only keep system prompt"""
+    def _clear_history(self):
+        """Clear conversation history while preserving system prompt.
+        
+        This will:
+        1. Clear the prompt
+        2. Reset the model
+        3. Reset conversation length counter
+        """
         self.prompt = "" 
         self.model.reset()
         self.conversation_length = 0  # Reset conversation length
@@ -338,7 +393,7 @@ Please continue the task based on the above information.
 
 
 
-def load_tasks() -> dict:
+def _load_tasks() -> dict:
     """Load tasks from .jarvis files in user home and current directory."""
     tasks = {}
     
@@ -375,18 +430,20 @@ def load_tasks() -> dict:
         except Exception as e:
             PrettyOutput.print(f"Error loading .jarvis/pre-command file: {str(e)}", OutputType.ERROR)
 
-    # Read methodology
-    method_path = os.path.expanduser("~/.jarvis/methodology")
-    if os.path.exists(method_path):
-        with open(method_path, "r", encoding="utf-8") as f:
-            methodology = yaml.safe_load(f)
-        if isinstance(methodology, dict):
-            for name, desc in methodology.items():
-                tasks[f"Run Methodology: {str(name)}\n {str(desc)}" ] = str(desc)
+    
+    if is_use_methodology():
+        # Read methodology
+        method_path = os.path.expanduser("~/.jarvis/methodology")
+        if os.path.exists(method_path):
+            with open(method_path, "r", encoding="utf-8") as f:
+                methodology = yaml.safe_load(f)
+            if isinstance(methodology, dict):
+                for name, desc in methodology.items():
+                    tasks[f"Run Methodology: {str(name)}\n {str(desc)}" ] = str(desc)
     
     return tasks
 
-def select_task(tasks: dict) -> str:
+def _select_task(tasks: dict) -> str:
     """Let user select a task from the list or skip. Returns task description if selected."""
     if not tasks:
         return ""
@@ -462,9 +519,9 @@ def main():
         agent = Agent(system_prompt=origin_agent_system_prompt, tool_registry=ToolRegistry())
 
         # 加载预定义任务
-        tasks = load_tasks()
+        tasks = _load_tasks()
         if tasks:
-            selected_task = select_task(tasks)
+            selected_task = _select_task(tasks)
             if selected_task:
                 PrettyOutput.print(f"\nExecute task: {selected_task}", OutputType.INFO)
                 agent.run(selected_task, args.files)

jarvis/jarvis_code_agent/code_agent.py

@@ -1,17 +1,13 @@
-from enum import auto
 import os
-import re
 from typing import List
 
-import yaml
 from jarvis.agent import Agent
 from jarvis.jarvis_code_agent.patch import apply_patch
-from jarvis.jarvis_code_agent.file_select import select_files
 from jarvis.jarvis_code_agent.relevant_files import find_relevant_files
-from jarvis.models.registry import PlatformRegistry
-from jarvis.tools.git_commiter import GitCommitTool
-from jarvis.tools.registry import ToolRegistry
-from jarvis.utils import OutputType, PrettyOutput, get_file_line_count, get_multiline_input, get_single_line_input, has_uncommitted_changes, init_env, find_git_root, is_disable_codebase, make_choice_input, user_confirm
+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_file_line_count, get_multiline_input, has_uncommitted_changes, init_env, find_git_root
 
 
 
@@ -21,7 +17,18 @@ class CodeAgent:
     def __init__(self):
         self.root_dir = os.getcwd()
         tool_registry = ToolRegistry()
-        tool_registry.use_tools(["read_code", "execute_shell", "search", "ask_user", "ask_codebase"])
+        tool_registry.use_tools(["read_code",
+                                 "execute_shell", 
+                                 "search", 
+                                 "create_code_agent",
+                                 "ask_user", 
+                                 "ask_codebase", 
+                                 "lsp_get_document_symbols", 
+                                 "lsp_get_diagnostics", 
+                                 "lsp_find_references", 
+                                 "lsp_find_definition", 
+                                 "lsp_prepare_rename", 
+                                 "lsp_validate_edit"])
         code_system_prompt = """
 You are a code agent, you are responsible for modifying the code.
 
@@ -30,23 +37,109 @@ You should read the code and analyze the code, and then provide a plan for the c
 ## Workflow Steps
 
 1. ANALYSIS
-- Understand the requirement thoroughly
-- Identify which files need to be modified
-- Review the current implementation
-- Consider potential impacts
+- 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
-- Consider dependencies between changes
-- Plan the implementation sequence
-- Think about potential risks
+- 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. Read and understand the current code
-b. Plan the specific modifications
-c. Write the patch in the required format
-d. Review the patch for correctness
+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
 
@@ -130,6 +223,24 @@ Note: In this example:
 - 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.
@@ -142,7 +253,7 @@ Then provide the necessary patches in the specified format.
                            tool_registry=tool_registry, 
                            platform=PlatformRegistry().get_codegen_platform(), 
                            record_methodology=False,
-                           output_filter=[apply_patch],
+                           output_handler_after_tool=[apply_patch],
                            need_summary=False)
 
     

jarvis/jarvis_code_agent/patch.py

@@ -1,9 +1,8 @@
 import re
-from typing import Dict, Any, List, Tuple
+from typing import Dict, Any, List
 import os
-from jarvis.tools.git_commiter import GitCommitTool
-from jarvis.tools.read_code import ReadCodeTool
-from jarvis.utils import OutputType, PrettyOutput, has_uncommitted_changes, make_choice_input, user_confirm
+from jarvis.jarvis_tools.git_commiter import GitCommitTool
+from jarvis.utils import OutputType, PrettyOutput, has_uncommitted_changes, user_confirm
 
 
 def _parse_patch(patch_str: str) -> Dict[str, List[Dict[str, Any]]]:
@@ -60,9 +59,7 @@ def _parse_patch(patch_str: str) -> Dict[str, List[Dict[str, Any]]]:
 def apply_patch(output_str: str)->str:
     """Apply patches to files"""
     patches = _parse_patch(output_str)
-    if not patches:
-        return ""
-        
+
     for filepath, patch_info in patches.items():
         try:
             # Check if file exists