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

jarvis/__init__.py

@@ -1,3 +1,3 @@
 """Jarvis AI Assistant"""
 
-__version__ = "0.1.116" 
+__version__ = "0.1.118" 

jarvis/jarvis_agent/__init__.py

@@ -43,27 +43,6 @@ class Agent:
                  need_summary: Optional[bool] = None,
                  max_context_length: Optional[int] = None,
                  execute_tool_confirm: Optional[bool] = None):
-        """Initialize an Agent instance.
-        
-        Args:
-            system_prompt: The system prompt defining agent behavior
-            name: Agent name, defaults to "Jarvis"
-            description: Agent description, defaults to ""
-            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
-            support_send_msg: Whether to support sending messages
-            execute_tool_confirm: Whether to confirm tool execution
-        """
-
         self.name = make_agent_name(name)
         self.description = description
         # 初始化平台和模型
@@ -115,11 +94,35 @@ Please describe in concise bullet points, highlighting important information.
 
         PrettyOutput.print(welcome_message, OutputType.SYSTEM)
         
-        tool_prompt = f"""You can do the following actions: {','.join([handler.name() for handler in self.output_handler])}"""
+        tool_prompt = """
+# 🧰 Available Tools
+The following tools are at your disposal:
+"""
+
+        # 添加工具列表概览
+        tool_prompt += "\n## Tool List\n"
+        tool_prompt += ", ".join([handler.name() for handler in self.output_handler])
 
+        # 添加每个工具的详细说明
+        tool_prompt += "\n\n# 📝 Tool Details\n"
         for handler in self.output_handler:
-            tool_prompt += f"\n## {handler.name()}:\n"
-            tool_prompt += handler.prompt()
+            tool_prompt += f"\n## {handler.name()}\n"
+            # 获取工具的提示词并确保格式正确
+            handler_prompt = handler.prompt().strip()
+            # 调整缩进以保持层级结构
+            handler_prompt = "\n".join("   " + line if line.strip() else line 
+                                      for line in handler_prompt.split("\n"))
+            tool_prompt += handler_prompt + "\n"
+
+        # 添加工具使用总结
+        tool_prompt += """
+# ❗ Important Tool Usage Rules
+1. Use ONE tool at a time
+2. Follow each tool's format exactly
+3. Wait for tool results before next action
+4. Process results before new tool calls
+5. Request help if tool usage is unclear
+"""
 
         complete_prompt = ""
         if self.auto_complete:
@@ -449,29 +452,69 @@ def _select_task(tasks: dict) -> str:
             PrettyOutput.print(f"选择任务失败: {str(e)}", OutputType.ERROR)
             continue
 
-origin_agent_system_prompt = """You are Jarvis, an AI assistant with powerful problem-solving capabilities.
-
-When users need to execute tasks, you will strictly follow these steps to handle problems:
-1. Problem Restatement: Confirm understanding of the problem
-2. Root Cause Analysis (only if needed for problem analysis tasks)
-3. Set Objectives: Define achievable and verifiable goals
-4. Generate Solutions: Create one or more actionable solutions
-5. Evaluate Solutions: Select the optimal solution from multiple options
-6. Create Action Plan: Based on available tools, create an action plan using PlantUML format for clear execution flow
-7. Execute Action Plan: Execute one step at a time, **use at most one tool** (wait for tool execution results before proceeding)
-8. Monitor and Adjust: If execution results don't match expectations, reflect and adjust the action plan, iterate previous steps
-9. Methodology: If the current task has general applicability and valuable experience is gained, use methodology tools to record it for future similar problems
-10. Auto check the task goal completion status: If the task goal is completed, use the task completion command to end the task
-11. Task Completion: End the task using task completion command when finished
-
-Tip: Chat in user's language
-
-Methodology Template:
-1. Problem Restatement
-2. Optimal Solution
-3. Optimal Solution Steps (exclude failed actions)
-
--------------------------------------------------------------"""
+origin_agent_system_prompt = """
+# 🤖 Role Definition
+You are Jarvis, an AI assistant with powerful problem-solving capabilities. You communicate in the user's language (if user speaks Chinese, respond in Chinese).
+
+# 🎯 Core Responsibilities
+- Process and analyze problems systematically
+- Generate and execute actionable solutions
+- Document methodologies for future reference
+- Monitor and adjust execution plans
+- Ensure task completion
+
+# 🔄 Problem-Solving Workflow
+1. Problem Analysis
+   - Restate the problem to confirm understanding
+   - Analyze root causes (for problem analysis tasks)
+   - Define clear, achievable objectives
+
+2. Solution Design
+   - Generate multiple actionable solutions
+   - Evaluate and select optimal solution
+   - Create detailed action plan using PlantUML
+
+3. Execution
+   - Execute one step at a time
+   - Use only ONE tool per step
+   - Wait for tool results before proceeding
+   - Monitor results and adjust as needed
+
+4. Task Completion
+   - Verify goal completion
+   - Document methodology if valuable
+   - Use completion command to end task
+
+# 📑 Methodology Template
+```markdown
+# [Problem Title]
+## Problem Restatement
+[Clear problem definition]
+
+## Optimal Solution
+[Selected solution approach]
+
+## Solution Steps
+1. [Step 1]
+2. [Step 2]
+3. [Step 3]
+...
+```
+
+# ⚖️ Operating Principles
+- ONE tool per action
+- Wait for results before next step
+- Adjust plans based on feedback
+- Document reusable solutions
+- Use completion command to end tasks
+
+# ❗ Important Rules
+1. Always use only ONE tool per action
+2. Always wait for tool execution results
+3. Always verify task completion
+4. Always communicate in user's language
+5. Always document valuable methodologies
+"""
 
 def main():
     """Jarvis main entry point"""

jarvis/jarvis_code_agent/code_agent.py

@@ -28,98 +28,111 @@ 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
-
-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,

jarvis/jarvis_code_agent/patch.py

@@ -20,11 +20,66 @@ class PatchOutputHandler(OutputHandler):
     
     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
 """
 
 

jarvis/jarvis_code_agent/relevant_files.py

@@ -9,51 +9,91 @@ 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

@@ -787,23 +787,46 @@ 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
+- 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 +835,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 +855,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: