jarvis-ai-assistant 0.1.101__py3-none-any.whl → 0.1.103__py3-none-any.whl

jarvis/jarvis_code_agent/main.py

@@ -1,202 +0,0 @@
-from jarvis.agent import Agent
-from jarvis.tools.registry import ToolRegistry
-from jarvis.utils import OutputType, PrettyOutput, get_multiline_input, init_env
-
-
-
-
-system_prompt = """You are Jarvis Code Agent, an AI code development assistant specialized in code analysis, modification, and version control. Your role is to help users with coding tasks systematically and reliably.
-
-DEVELOPMENT WORKFLOW:
-1. Task Analysis
-   - Understand the requirements thoroughly
-   - IMPORTANT: Before suggesting any changes:
-     * Thoroughly examine existing code implementation
-     * Never assume code structure or implementation details
-     * Always verify current code behavior and patterns
-   - Break down complex tasks into subtasks
-   - IMPORTANT: Each subtask should:
-     * Modify only ONE file
-     * Change no more than 20 lines of code
-     * Be focused and atomic
-   - Define success criteria
-
-2. Code Discovery & Analysis
-   - Initial code search:
-     * CRITICAL: Always examine actual code implementation first
-     * Use shell commands to find and understand patterns:
-       <TOOL_CALL>
-       name: execute_shell
-       arguments:
-           command: grep -r 'pattern' directory/
-       </TOOL_CALL>
-       <TOOL_CALL>
-       name: execute_shell
-       arguments:
-           command: grep -A 5 -B 5 'pattern' file.py
-       </TOOL_CALL>
-     * Use shell commands to locate files:
-       <TOOL_CALL>
-       name: execute_shell
-       arguments:
-           command: find . -name 'pattern'
-       </TOOL_CALL>
-     * Use shell commands to preview:
-       <TOOL_CALL>
-       name: execute_shell
-       arguments:
-           command: head -n 50 file.py
-       </TOOL_CALL>
-   - File selection and confirmation:
-     * Let user confirm selection:
-       <TOOL_CALL>
-       name: select_code_files
-       arguments:
-           related_files:
-               - auth.py
-               - user.py
-           root_dir: .
-       </TOOL_CALL>
-
-3. Modification Planning
-   - CRITICAL: Base all plans on actual code implementation, not assumptions
-   - Generate a detailed modification plan based on:
-     * Current code structure and patterns
-     * Existing implementation details
-     * User requirements
-     * Actual code conditions
-
-4. Code Implementation
-   - For small changes (≤20 lines):
-     <TOOL_CALL>
-     name: execute_code_modification
-     arguments:
-         task: Add password validation
-         structured_plan:
-             auth.py: Add password strength check in validate_password()
-     </TOOL_CALL>
-   - For large changes:
-     <TOOL_CALL>
-     name: create_code_sub_agent
-     arguments:
-         subtask: Implement new authentication flow
-         codebase_dir: .
-     </TOOL_CALL>
-
-FILE SELECTION WORKFLOW:
-1. Initial Search
-   - Use shell commands to find relevant files
-   - Review search results for relevance
-
-2. User Confirmation
-   - Use select_code_files to:
-     * Display found files
-     * Let user review selection
-     * Allow file list adjustment
-     * Enable file supplementation
-
-3. File Validation
-   - Verify selected files exist
-   - Check file permissions
-   - Validate file types
-   - Ensure completeness
-
-CODE SEARCH BEST PRACTICES:
-- Use grep for pattern matching:
-  * grep -r "pattern" directory/
-  * grep -A 5 -B 5 for context
-  * grep -n for line numbers
-- Use find for file location:
-  * find . -name "pattern"
-  * find . -type f -exec grep "pattern" {} \\;
-- Use head/tail for previews:
-  * head -n 50 file.py
-  * tail -n 50 file.py
-  * head -n +100 | tail -n 50
-- Avoid loading entire large files
-- Focus on relevant sections
-- Use line numbers for reference
-
-SUBTASK MANAGEMENT RULES:
-- One subtask = One file modification
-- Each subtask ≤20 lines of code changes
-- Break down larger changes into multiple subtasks
-- Create separate sub-agent for each subtask
-- Follow dependency order in execution
-- Verify each change independently
-
-CODE MODIFICATION LIMITS:
-- Maximum 20 lines per change
-- Count both added and modified lines
-- Exclude comment and blank lines
-- Include only actual code changes
-- Split larger changes into subtasks
-
-ITERATION GUIDELINES:
-- Each iteration should be small and focused
-- Keep changes minimal and clear
-- Verify changes before moving forward
-- Document issues and solutions
-- Learn from previous iterations
-
-TOOL USAGE:
-1. Analysis Tools:
-   - execute_shell: Run grep/find/head/tail commands
-   - find_files: Search and identify relevant code files in the codebase based on requirements or problems
-   - select_code_files: Confirm and supplement files
-   - ask_user: Ask user for confirmation and information if needed
-   - create_code_sub_agent: Create agent for each small change
-   - file_operation: Read files
-   - rag: Ask questions based on a document directory, supporting multiple document formats (txt, pdf, docx, etc.)
-   - search: Use Bing search engine to search for information, and extract key information based on the question
-   - thinker: Deep thinking and logical reasoning
-
-2. Planning Tools:
-   - thinker: Generate a detailed modification plan based on user requirements and actual code conditions.
-   - create_code_sub_agent: Create agent for each small change
-   - ask_user: Ask user for confirmation and information if needed
-
-3. Implementation Tools:
-   - execute_shell: Run shell commands, some changes can use sed/awk/etc. to modify the code
-   - execute_code_modification: Apply small changes (≤20 lines)
-   - file_operation: Read, write, or append to files
-
-IMPORTANT:
-1. If you can start executing the task, please start directly without asking the user if you can begin.
-2. NEVER assume code structure or implementation - always examine the actual code first.
-3. Base all suggestions and modifications on the current implementation, not assumptions.
-4. If code implementation is unclear, use available tools to investigate before proceeding.
-5. Before you start modifying the code, you should ask the user for confirmation of the modification plan.
-6. For some small changes, you can modify the code using the execute_shell tool directly or use file_operation tool to read the file and modify it.
-"""
-
-def main():
-    """Jarvis main entry point"""
-    # Add argument parser
-    init_env()
-
-
-    try:
-        tool_registry = ToolRegistry()
-        tool_registry.dont_use_tools(["create_sub_agent"])
-        # Get global model instance
-        agent = Agent(system_prompt=system_prompt, name="Jarvis Code Agent", tool_registry=tool_registry)
-
-        # Interactive mode
-        while True:
-            try:
-                user_input = get_multiline_input("Please enter your task (input empty line to exit):")
-                if not user_input or user_input == "__interrupt__":
-                    break
-                agent.run(user_input)
-            except Exception as e:
-                PrettyOutput.print(f"Error: {str(e)}", OutputType.ERROR)
-
-    except Exception as e:
-        PrettyOutput.print(f"Initialization error: {str(e)}", OutputType.ERROR)
-        return 1
-
-    return 0
-
-if __name__ == "__main__":
-    exit(main())

jarvis/jarvis_coder/git_utils.py

@@ -1,123 +0,0 @@
-import os
-from typing import List
-import yaml
-import time
-from jarvis.utils import OutputType, PrettyOutput, find_git_root, while_success
-from jarvis.models.registry import PlatformRegistry
-
-def has_uncommitted_files() -> bool:
-    """Check if there are uncommitted files in the repository"""
-    # Get unstaged modifications
-    unstaged = os.popen("git diff --name-only").read()
-    # Get staged but uncommitted modifications
-    staged = os.popen("git diff --cached --name-only").read()
-    # Get untracked files
-    untracked = os.popen("git ls-files --others --exclude-standard").read()
-    
-    return bool(unstaged or staged or untracked)
-
-def generate_commit_message(git_diff: str) -> str:
-    """Generate commit message based on git diff and feature description"""
-    prompt = f"""You are an experienced programmer, please generate a concise and clear commit message based on the following code changes and feature description:
-
-Code changes:
-Git Diff:
-{git_diff}
-
-Please follow these rules:
-1. Write in English
-2. Use conventional commit message format: <type>(<scope>): <subject>
-3. Keep it concise, no more than 50 characters
-4. Accurately describe the main content of code changes
-5. Prioritize feature description and changes in git diff
-6. Only generate the commit message text, do not output anything else
-"""
-    
-    model = PlatformRegistry().get_global_platform_registry().get_normal_platform()
-    response = model.chat_until_success(prompt)
-        
-    return ';'.join(response.strip().split("\n"))
-
-def save_edit_record(record_dir: str, commit_message: str, git_diff: str) -> None:
-    """Save code modification record"""
-    # Get next sequence number
-    existing_records = [f for f in os.listdir(record_dir) if f.endswith('.yaml')]
-    next_num = 1
-    if existing_records:
-        last_num = max(int(f[:4]) for f in existing_records)
-        next_num = last_num + 1
-    
-    # Create record file
-    record = {
-        "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
-        "commit_message": commit_message,
-        "git_diff": git_diff
-    }
-    
-    record_path = os.path.join(record_dir, f"{next_num:04d}.yaml")
-    with open(record_path, "w", encoding="utf-8") as f:
-        yaml.safe_dump(record, f, allow_unicode=True)
-    
-    PrettyOutput.print(f"Modification record saved: {record_path}", OutputType.SUCCESS) 
-
-
-def init_git_repo(root_dir: str) -> str:
-    git_dir = find_git_root(root_dir)
-    if not git_dir:
-        git_dir = root_dir
-
-    PrettyOutput.print(f"Git root directory: {git_dir}", OutputType.INFO)
-
-    # 1. Check if the code repository path exists, if it does not exist, create it
-    if not os.path.exists(git_dir):
-        PrettyOutput.print(
-            "Root directory does not exist, creating...", OutputType.INFO)
-        os.makedirs(git_dir)
-
-    os.chdir(git_dir)
-
-    # 3. Process .gitignore file
-    gitignore_path = os.path.join(git_dir, ".gitignore")
-    gitignore_modified = False
-    jarvis_ignore_pattern = ".jarvis"
-
-    # 3.1 If .gitignore does not exist, create it
-    if not os.path.exists(gitignore_path):
-        PrettyOutput.print("Create .gitignore file", OutputType.INFO)
-        with open(gitignore_path, "w", encoding="utf-8") as f:
-            f.write(f"{jarvis_ignore_pattern}\n")
-        gitignore_modified = True
-    else:
-        # 3.2 Check if it already contains the .jarvis pattern
-        with open(gitignore_path, "r", encoding="utf-8") as f:
-            content = f.read()
-        
-        # 3.2 Check if it already contains the .jarvis pattern
-        if jarvis_ignore_pattern not in content.split("\n"):
-            PrettyOutput.print("Add .jarvis to .gitignore", OutputType.INFO)
-            with open(gitignore_path, "a", encoding="utf-8") as f:
-                # Ensure the file ends with a newline
-                if not content.endswith("\n"):
-                    f.write("\n")
-                f.write(f"{jarvis_ignore_pattern}\n")
-            gitignore_modified = True
-
-    # 4. Check if the code repository is a git repository, if not, initialize the git repository
-    if not os.path.exists(os.path.join(git_dir, ".git")):
-        PrettyOutput.print("Initialize Git repository", OutputType.INFO)
-        os.system("git init")
-        os.system("git add .")
-        os.system("git commit -m 'Initial commit'")
-    # 5. If .gitignore is modified, commit the changes
-    elif gitignore_modified:
-        PrettyOutput.print("Commit .gitignore changes", OutputType.INFO)
-        os.system("git add .gitignore")
-        os.system("git commit -m 'chore: update .gitignore to exclude .jarvis-* files'")
-    # 6. Check if there are uncommitted files in the code repository, if there are, commit once
-    elif has_uncommitted_files():
-        PrettyOutput.print("Commit uncommitted changes", OutputType.INFO)
-        os.system("git add .")
-        git_diff = os.popen("git diff --cached").read()
-        commit_message = generate_commit_message(git_diff)
-        os.system(f"git commit -m '{commit_message}'")
-    return git_dir

jarvis/jarvis_coder/main.py

@@ -1,241 +0,0 @@
-import os
-import threading
-from typing import Dict, Any, List, Optional
-import re
-
-from jarvis.jarvis_coder.file_select import select_files
-from jarvis.utils import OutputType, PrettyOutput, find_git_root, get_max_context_length, is_long_context, init_env, while_success
-from jarvis.models.registry import PlatformRegistry
-from jarvis.jarvis_codebase.main import CodeBase
-from prompt_toolkit import PromptSession
-from prompt_toolkit.completion import WordCompleter, Completer, Completion
-from prompt_toolkit.formatted_text import FormattedText
-from prompt_toolkit.styles import Style
-import fnmatch
-from .patch_handler import PatchHandler
-from .git_utils import generate_commit_message, init_git_repo, save_edit_record
-from .plan_generator import PlanGenerator
-
-# 全局锁对象
-index_lock = threading.Lock()
-
-class JarvisCoder:
-    def __init__(self, root_dir: str, language: Optional[str] = "python"):
-        """Initialize code modification tool"""
-        self.root_dir = root_dir
-        self.language = language
-        self._init_directories()
-        self._init_codebase()
-        
-    def _init_directories(self):
-        """Initialize directories"""
-        self.max_context_length = get_max_context_length()
-        self.root_dir = init_git_repo(self.root_dir)
-
-    def _init_codebase(self):
-        """Initialize codebase"""
-        self._codebase = CodeBase(self.root_dir)
-
-
-    def _load_related_files(self, feature: str) -> List[str]:
-        """Load related file content"""
-        ret = []
-        # Ensure the index database is generated
-        if not self._codebase.is_index_generated():
-            PrettyOutput.print("Index database not generated, generating...", OutputType.WARNING)
-            self._codebase.generate_codebase()
-            
-        related_files = self._codebase.search_similar(feature)
-        for file in related_files:
-            PrettyOutput.print(f"Related file: {file}", OutputType.SUCCESS)
-            ret.append(file)
-        return ret
-
-
-
-    def execute(self, feature: str) -> Dict[str, Any]:
-        """Execute code modification"""
-        try:
-            # Get and select related files
-            initial_files = self._load_related_files(feature)
-            selected_files = select_files(initial_files, self.root_dir)
-
-            # Get modification plan
-            structed_plan = PlanGenerator().generate_plan(feature, selected_files)
-            if not structed_plan:
-                return {
-                    "success": False,
-                    "stdout": "",
-                    "stderr": "Failed to generate modification plan, please modify the requirement and try again",
-                }
-            
-            # Execute modification
-            if PatchHandler().handle_patch_application(feature, structed_plan):
-                return {
-                    "success": True,
-                    "stdout": "Code modification successful",
-                    "stderr": "",
-                }
-            else:
-                return {
-                    "success": False,
-                    "stdout": "",
-                    "stderr": "Code modification failed, please modify the requirement and try again",
-                }
-                
-        except Exception as e:
-            return {
-                "success": False,
-                "stdout": "",
-                "stderr": f"Execution failed: {str(e)}, please modify the requirement and try again",
-            }
-
-def main():
-    """Command line entry"""
-    import argparse
-
-    init_env()
-    
-    parser = argparse.ArgumentParser(description='Code modification tool')
-    parser.add_argument('-d', '--dir', help='Project root directory', default=os.getcwd())
-    parser.add_argument('-l', '--language', help='Programming language', default="python")
-    args = parser.parse_args()
-    
-    tool = JarvisCoder(args.dir, args.language)
-    
-    # Loop through requirements
-    while True:
-        try:
-            # Get requirements, pass in project root directory
-            feature = get_multiline_input("Please enter the development requirements (input empty line to exit):", tool.root_dir)
-            
-            if not feature or feature == "__interrupt__":
-                break
-                
-            # Execute modification
-            result = tool.execute(feature)
-            
-            # Display results
-            if result["success"]:
-                PrettyOutput.print(result["stdout"], OutputType.SUCCESS)
-            else:
-                if result.get("stderr"):
-                    PrettyOutput.print(result["stderr"], OutputType.WARNING)
-                PrettyOutput.print("\nYou can modify the requirements and try again", OutputType.INFO)
-                
-        except KeyboardInterrupt:
-            print("\nUser interrupted execution")
-            break
-        except Exception as e:
-            PrettyOutput.print(f"Execution failed: {str(e)}", OutputType.ERROR)
-            PrettyOutput.print("\nYou can modify the requirements and try again", OutputType.INFO)
-            continue
-            
-    return 0
-
-if __name__ == "__main__":
-    exit(main())
-
-class FilePathCompleter(Completer):
-    """File path auto-completer"""
-    
-    def __init__(self, root_dir: str):
-        self.root_dir = root_dir
-        self._file_list = None
-        
-    def _get_files(self) -> List[str]:
-        """Get the list of files managed by git"""
-        if self._file_list is None:
-            try:
-                # Switch to project root directory
-                old_cwd = os.getcwd()
-                os.chdir(self.root_dir)
-                
-                # Get the list of files managed by git
-                self._file_list = os.popen("git ls-files").read().splitlines()
-                
-                # Restore working directory
-                os.chdir(old_cwd)
-            except Exception as e:
-                PrettyOutput.print(f"Failed to get file list: {str(e)}", OutputType.WARNING)
-                self._file_list = []
-        return self._file_list
-    
-    def get_completions(self, document, complete_event):
-        """Get completion suggestions"""
-        text_before_cursor = document.text_before_cursor
-        
-        # Check if @ was just entered
-        if text_before_cursor.endswith('@'):
-            # Display all files
-            for path in self._get_files():
-                yield Completion(path, start_position=0)
-            return
-            
-        # Check if there was an @ before, and get the search word after @
-        at_pos = text_before_cursor.rfind('@')
-        if at_pos == -1:
-            return
-            
-        search = text_before_cursor[at_pos + 1:].lower().strip()
-        
-        # Provide matching file suggestions
-        for path in self._get_files():
-            path_lower = path.lower()
-            if (search in path_lower or  # Directly included
-                search in os.path.basename(path_lower) or  # File name included
-                any(fnmatch.fnmatch(path_lower, f'*{s}*') for s in search.split())): # Wildcard matching
-                # Calculate the correct start_position
-                yield Completion(path, start_position=-(len(search)))
-
-
-def get_multiline_input(prompt_text: str, root_dir: Optional[str] = ".") -> str:
-    """Get multi-line input, support file path auto-completion function
-    
-    Args:
-        prompt_text: Prompt text
-        root_dir: Project root directory, for file completion
-        
-    Returns:
-        str: User input text
-    """
-    # Create file completion
-    file_completer = FilePathCompleter(root_dir or os.getcwd())
-    
-    # Create prompt style
-    style = Style.from_dict({
-        'prompt': 'ansicyan bold',
-        'input': 'ansiwhite',
-    })
-    
-    # Create session
-    session = PromptSession(
-        completer=file_completer,
-        style=style,
-        multiline=False,
-        enable_history_search=True,
-        complete_while_typing=True
-    )
-    
-    # Display initial prompt text
-    print(f"\n{prompt_text}")
-    
-    # Create prompt
-    prompt = FormattedText([
-        ('class:prompt', ">>> ")
-    ])
-    
-    # Get input
-    lines = []
-    try:
-        while True:
-            line = session.prompt(prompt).strip()
-            if not line:  # Empty line means input end
-                break
-            lines.append(line)
-    except KeyboardInterrupt:
-        return "__interrupt__"
-    except EOFError:
-        pass
-    
-    return "\n".join(lines)