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

jarvis/__init__.py

@@ -1,3 +1,3 @@
 """Jarvis AI Assistant"""
 
-__version__ = "0.1.101" 
+__version__ = "0.1.102" 

jarvis/agent.py

@@ -8,7 +8,7 @@ import yaml
 from jarvis.models.registry import PlatformRegistry
 from jarvis.tools import ToolRegistry
 from jarvis.tools.registry import load_tools
-from jarvis.utils import PrettyOutput, OutputType, get_single_line_input, load_methodology, add_agent, delete_current_agent, get_max_context_length, get_multiline_input, load_embedding_model, init_env
+from jarvis.utils import PrettyOutput, OutputType, get_single_line_input, load_methodology, add_agent, delete_current_agent, get_max_context_length, get_multiline_input, init_env
 import os
 
 class Agent:
@@ -35,29 +35,9 @@ class Agent:
         self.conversation_length = 0  # Use length counter instead
         self.system_prompt = system_prompt
         # Load configuration from environment variables
-        self.embedding_dimension = 1536  # Default for many embedding models
+        
         self.max_context_length = get_max_context_length()
         
-        # Initialize embedding model
-        try:
-            self.embedding_model = load_embedding_model()
-            
-            # Warm up model and get correct dimension
-            test_text = "This is a test text to ensure the model is fully loaded."
-            test_embedding = self.embedding_model.encode(
-                test_text, 
-                convert_to_tensor=True,
-                normalize_embeddings=True
-            )
-            self.embedding_dimension = len(test_embedding)
-            PrettyOutput.print("Successfully loaded embedding model", OutputType.SUCCESS)
-            
-            # Initialize HNSW index (use correct dimension)
-            
-            
-        except Exception as e:
-            PrettyOutput.print(f"Failed to load embedding model: {str(e)}", OutputType.ERROR)
-            raise
             
         # Initialize methodology related attributes
         self.methodology_data = []
@@ -441,7 +421,6 @@ Strict Rules:
 - Don't create fake dialogues
 - If current information is insufficient, you may ask the user
 - Not all problem-solving steps are mandatory, skip as appropriate
-- Ask user before executing tools that might damage system or user's codebase
 - Request user guidance when multiple iterations show no progress
 - If yaml string contains colons, wrap the entire string in quotes to avoid yaml parsing errors
 - Use | syntax for multi-line strings in yaml
@@ -459,7 +438,7 @@ def main():
 
     try:
         # 获取全局模型实例
-        agent = Agent(system_prompt=origin_agent_system_prompt)
+        agent = Agent(system_prompt=origin_agent_system_prompt, tool_registry=ToolRegistry())
 
         # 加载预定义任务
         tasks = load_tasks()

jarvis/jarvis_code_agent/main.py

@@ -79,8 +79,8 @@ DEVELOPMENT WORKFLOW:
      <TOOL_CALL>
      name: create_code_sub_agent
      arguments:
+         name: code_sub_agent
          subtask: Implement new authentication flow
-         codebase_dir: .
      </TOOL_CALL>
 
 FILE SELECTION WORKFLOW:
@@ -147,10 +147,8 @@ TOOL USAGE:
    - 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

jarvis/jarvis_github/main.py

@@ -0,0 +1,232 @@
+import os
+import sys
+import argparse
+from typing import Dict, List, Optional
+import yaml
+
+from jarvis.agent import Agent
+from jarvis.utils import PrettyOutput, OutputType, get_single_line_input, init_env
+from jarvis.tools import ToolRegistry
+
+# System prompt for the GitHub workflow agent
+github_workflow_prompt = """You are a GitHub Workflow Agent that helps manage the complete development workflow using GitHub CLI (gh). Follow these steps strictly:
+
+1. Environment Check:
+   - Verify gh CLI installation
+   - Check authentication status
+   - Set up authentication if needed
+
+2. Issue Management:
+   - List and display available issues
+   - Help user select an issue to work on
+   - Analyze the selected issue thoroughly
+
+3. Development Planning:
+   - Create a development branch for the issue
+   - Generate a detailed modification plan
+   - Break down the task into smaller steps
+
+4. Implementation:
+   - Guide through the implementation process
+   - Track changes and progress
+   - Ensure code quality
+
+5. Review and Submit:
+   - Review changes before submission
+   - Create and submit pull request
+   - Handle review feedback
+   - Close the issue upon completion
+
+Always follow GitHub best practices and provide clear feedback at each step.
+"""
+
+def check_gh_installation() -> bool:
+    """Check if GitHub CLI is installed"""
+    return os.system("gh --version > /dev/null 2>&1") == 0
+
+def check_gh_auth() -> bool:
+    """Check if GitHub CLI is authenticated"""
+    return os.system("gh auth status > /dev/null 2>&1") == 0
+
+def setup_gh_auth() -> bool:
+    """Guide user through GitHub CLI authentication"""
+    PrettyOutput.print("Starting GitHub CLI authentication...", OutputType.INFO)
+    return os.system("gh auth login") == 0
+
+def list_issues() -> List[Dict]:
+    """List all available issues"""
+    try:
+        # Get issues in JSON format
+        result = os.popen("gh issue list --json number,title,body,url").read()
+        issues = yaml.safe_load(result)
+        return issues
+    except Exception as e:
+        PrettyOutput.print(f"Error listing issues: {str(e)}", OutputType.ERROR)
+        return []
+
+def select_issue(issues: List[Dict]) -> Optional[Dict]:
+    """Display issues and let user select one"""
+    if not issues:
+        PrettyOutput.print("No issues found.", OutputType.WARNING)
+        return None
+    
+    PrettyOutput.print("\nAvailable Issues:", OutputType.INFO)
+    for i, issue in enumerate(issues, 1):
+        print(f"{i}. #{issue['number']} - {issue['title']}")
+    
+    while True:
+        try:
+            choice = get_single_line_input("\nSelect an issue number (or 0 to exit): ")
+            if not choice or choice == "0":
+                return None
+            
+            index = int(choice) - 1
+            if 0 <= index < len(issues):
+                return issues[index]
+            else:
+                PrettyOutput.print("Invalid selection. Please try again.", OutputType.WARNING)
+        except ValueError:
+            PrettyOutput.print("Please enter a valid number.", OutputType.WARNING)
+
+def create_development_branch(issue_number: int) -> bool:
+    """Create a development branch for the issue"""
+    try:
+        result = os.system(f"gh issue develop {issue_number} --checkout")
+        return result == 0
+    except Exception as e:
+        PrettyOutput.print(f"Error creating branch: {str(e)}", OutputType.ERROR)
+        return False
+
+def create_pull_request(issue_number: int, title: str, body: str) -> bool:
+    """Create a pull request for the changes"""
+    try:
+        cmd = f'gh pr create --title "{title}" --body "{body}" --issue {issue_number}'
+        result = os.system(cmd)
+        return result == 0
+    except Exception as e:
+        PrettyOutput.print(f"Error creating pull request: {str(e)}", OutputType.ERROR)
+        return False
+
+def close_issue(issue_number: int) -> bool:
+    """Close the issue"""
+    try:
+        result = os.system(f"gh issue close {issue_number}")
+        return result == 0
+    except Exception as e:
+        PrettyOutput.print(f"Error closing issue: {str(e)}", OutputType.ERROR)
+        return False
+
+def install_gh_linux() -> bool:
+    """Install GitHub CLI on Linux"""
+    PrettyOutput.print("Installing GitHub CLI...", OutputType.INFO)
+    
+    # Detect package manager
+    package_managers = {
+        "apt": "curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | sudo dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg && \
+                echo \"deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main\" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null && \
+                sudo apt update && sudo apt install gh -y",
+        "dnf": "sudo dnf install 'dnf-command(config-manager)' -y && \
+                sudo dnf config-manager --add-repo https://cli.github.com/packages/rpm/gh-cli.repo && \
+                sudo dnf install gh -y",
+        "yum": "sudo yum install 'dnf-command(config-manager)' -y && \
+                sudo yum config-manager --add-repo https://cli.github.com/packages/rpm/gh-cli.repo && \
+                sudo yum install gh -y",
+        "pacman": "sudo pacman -S github-cli --noconfirm",
+    }
+    
+    # Try to detect the package manager
+    for pm, cmd in package_managers.items():
+        if os.system(f"which {pm} > /dev/null 2>&1") == 0:
+            PrettyOutput.print(f"Detected {pm} package manager", OutputType.INFO)
+            if os.system(cmd) == 0:
+                PrettyOutput.print("GitHub CLI installed successfully!", OutputType.SUCCESS)
+                return True
+            else:
+                PrettyOutput.print(f"Failed to install using {pm}", OutputType.ERROR)
+                return False
+    
+    PrettyOutput.print(
+        "Could not detect supported package manager. Please install manually:\n"
+        "https://github.com/cli/cli/blob/trunk/docs/install_linux.md",
+        OutputType.ERROR
+    )
+    return False
+
+def main():
+    """Main entry point for GitHub workflow"""
+    init_env()
+    
+    # Check GitHub CLI installation
+    if not check_gh_installation():
+        if sys.platform.startswith('linux'):
+            if not install_gh_linux():
+                return 1
+        else:
+            PrettyOutput.print(
+                "GitHub CLI (gh) is not installed. Please install it first:\n"
+                "- Windows: winget install GitHub.cli\n"
+                "- macOS: brew install gh\n"
+                "- Linux: See https://github.com/cli/cli/blob/trunk/docs/install_linux.md",
+                OutputType.ERROR
+            )
+            return 1
+    
+    # Check authentication
+    if not check_gh_auth():
+        PrettyOutput.print("GitHub CLI needs authentication.", OutputType.WARNING)
+        if not setup_gh_auth():
+            PrettyOutput.print("Authentication failed. Please try again.", OutputType.ERROR)
+            return 1
+    
+    # List and select issue
+    issues = list_issues()
+    selected_issue = select_issue(issues)
+    if not selected_issue:
+        PrettyOutput.print("No issue selected. Exiting.", OutputType.INFO)
+        return 0
+    
+    # Create GitHub workflow agent
+    tool_registry = ToolRegistry()
+    agent = Agent(
+        system_prompt=github_workflow_prompt,
+        name="GitHub Workflow Agent",
+        tool_registry=tool_registry
+    )
+    
+    # Start the workflow
+    try:
+        # Create development branch
+        if not create_development_branch(selected_issue['number']):
+            return 1
+        
+        # Run the agent with the selected issue
+        workflow_request = f"""
+        Working on issue #{selected_issue['number']}: {selected_issue['title']}
+        
+        Issue description:
+        {selected_issue['body']}
+        
+        Please guide through the development process and help create a pull request.
+        """
+        
+        result = agent.run(workflow_request)
+        
+        # Create pull request and close issue if successful
+        if result and "success" in result.lower():
+            if create_pull_request(
+                selected_issue['number'],
+                f"Fix #{selected_issue['number']}: {selected_issue['title']}",
+                "Implements the requested changes and fixes the issue."
+            ):
+                close_issue(selected_issue['number'])
+                PrettyOutput.print("Workflow completed successfully!", OutputType.SUCCESS)
+                return 0
+    
+    except Exception as e:
+        PrettyOutput.print(f"Error in workflow: {str(e)}", OutputType.ERROR)
+        return 1
+    
+    return 1
+
+if __name__ == "__main__":
+    sys.exit(main())

jarvis/models/ai8.py

@@ -14,6 +14,7 @@ class AI8Model(BasePlatform):
 
     def get_model_list(self) -> List[Tuple[str, str]]:
         """获取模型列表"""
+        self.get_available_models()
         return [(name,info['desc']) for name,info in self.models.items()]
     
     def __init__(self):
@@ -30,9 +31,7 @@ class AI8Model(BasePlatform):
         
         
         self.model_name = os.getenv("JARVIS_MODEL") or "deepseek-chat"
-        if self.model_name not in self.get_available_models():
-            PrettyOutput.print(f"Warning: The selected model {self.model_name} is not in the available list", OutputType.WARNING)
-        
+
 
     def set_model_name(self, model_name: str):
         """Set model name"""

jarvis/models/oyi.py

@@ -14,6 +14,7 @@ class OyiModel(BasePlatform):
 
     def get_model_list(self) -> List[Tuple[str, str]]:
         """Get model list"""
+        self.get_available_models()
         return [(name,info['desc']) for name,info in self.models.items()]
     
     def __init__(self):
@@ -31,9 +32,6 @@ class OyiModel(BasePlatform):
             PrettyOutput.print("OYI_API_KEY is not set", OutputType.WARNING)
         
         self.model_name = os.getenv("JARVIS_MODEL") or "deepseek-chat"
-        if self.model_name not in [m.split()[0] for m in self.get_available_models()]:
-            PrettyOutput.print(f"Warning: The selected model {self.model_name} is not in the available list", OutputType.WARNING)
-        
 
     def set_model_name(self, model_name: str):
         """Set model name"""

jarvis/tools/registry.py

@@ -22,7 +22,6 @@ def load_tools() -> str:
             tools_prompt += f"- Name: {tool['name']}\n"
             tools_prompt += f"  Description: {tool['description']}\n"
             tools_prompt += f"  Parameters: {tool['parameters']}\n"
-            tools_prompt += f"  Usage Format: <TOOL_CALL>\n"
         tools_prompt += """
 Tool Usage Format:
 
@@ -106,48 +105,55 @@ class ToolRegistry:
                 PrettyOutput.print(f"File does not exist: {p_file_path}", OutputType.ERROR)
                 return False
                 
-            # Dynamically import the module
-            module_name = p_file_path.stem
-            spec = importlib.util.spec_from_file_location(module_name, p_file_path) # type: ignore
-            if not spec or not spec.loader:
-                PrettyOutput.print(f"Failed to load module: {p_file_path}", OutputType.ERROR)
-                return False
-                
-            module = importlib.util.module_from_spec(spec) # type: ignore
-            sys.modules[module_name] = module  # Add to sys.modules to support relative imports
-            spec.loader.exec_module(module)
+            # Add the parent directory to sys.path temporarily
+            parent_dir = str(p_file_path.parent)
+            sys.path.insert(0, parent_dir)
             
-            # Find the tool class in the module
-            tool_found = False
-            for item_name in dir(module):
-                item = getattr(module, item_name)
-                # Check if it is a class and has the necessary attributes
-                if (isinstance(item, type) and 
-                    hasattr(item, 'name') and 
-                    hasattr(item, 'description') and 
-                    hasattr(item, 'parameters')):
-                    
-                    # Instantiate the tool class, passing in the model and output processor
-                    tool_instance = item()
-                    
-                    # Register the tool
-                    self.register_tool(
-                        name=tool_instance.name,
-                        description=tool_instance.description,
-                        parameters=tool_instance.parameters,
-                        func=tool_instance.execute
-                    )
-                    tool_found = True
-                    break
+            try:
+                # Import the module using standard import mechanism
+                module_name = p_file_path.stem
+                module = __import__(module_name)
+                
+                # Find the tool class in the module
+                tool_found = False
+                for item_name in dir(module):
+                    item = getattr(module, item_name)
+                    # Check if it is a class and has the necessary attributes
+                    if (isinstance(item, type) and 
+                        hasattr(item, 'name') and 
+                        hasattr(item, 'description') and 
+                        hasattr(item, 'parameters')):
+
+                        if hasattr(item, "check"):
+                            if not item.check():
+                                PrettyOutput.print(f"Tool {item.name} check failed, skipping", OutputType.INFO)
+                                continue
+                        
+                        # Instantiate the tool class
+                        tool_instance = item()
+                        
+                        # Register the tool
+                        self.register_tool(
+                            name=tool_instance.name,
+                            description=tool_instance.description,
+                            parameters=tool_instance.parameters,
+                            func=tool_instance.execute
+                        )
+                        tool_found = True
+                        break
+                        
+                if not tool_found:
+                    PrettyOutput.print(f"No valid tool class found in the file: {p_file_path}", OutputType.INFO)
+                    return False
                     
-            if not tool_found:
-                PrettyOutput.print(f"No valid tool class found in the file: {p_file_path}", OutputType.WARNING)
-                return False
+                return True
+                
+            finally:
+                # Remove the directory from sys.path
+                sys.path.remove(parent_dir)
                 
-            return True
-            
         except Exception as e:
-            PrettyOutput.print(f"Failed to load tool from {p_file_path.name}: {str(e)}", OutputType.ERROR)
+            PrettyOutput.print(f"Failed to load tool from {Path(file_path).name}: {str(e)}", OutputType.ERROR)
             return False
 
     def register_tool(self, name: str, description: str, parameters: Dict, func: Callable):
@@ -264,7 +270,9 @@ Please provide a summary:"""
             
             else:
                 PrettyOutput.section("Execution failed", OutputType.WARNING)
-                
+            
+            if len(tool_calls) > 1:
+                output += f"\n\n--- 一次只能执行一个工具, 因此以下工具未执行\n{str(tool_calls[1:])} ---"
             return output
             
         except Exception as e:

jarvis/utils.py

@@ -1,4 +1,3 @@
-from ast import List, Str
 import hashlib
 from pathlib import Path
 import sys
@@ -6,18 +5,14 @@ import time
 import os
 from enum import Enum
 from datetime import datetime
-from typing import Any, Dict
+from typing import Any
 import colorama
 from colorama import Fore, Style as ColoramaStyle
 import numpy as np
 from prompt_toolkit import PromptSession
 from prompt_toolkit.styles import Style as PromptStyle
 from prompt_toolkit.formatted_text import FormattedText
-from sentence_transformers import SentenceTransformer
-from transformers import AutoModelForSequenceClassification, AutoTokenizer
-import torch
 import yaml
-import faiss
 
 # 初始化colorama
 colorama.init()
@@ -244,70 +239,6 @@ def find_git_root(dir="."):
     os.chdir(curr_dir)
     return ret
 
-def load_embedding_model():
-    model_name = "BAAI/bge-m3"
-    cache_dir = os.path.expanduser("~/.cache/huggingface/hub")
-    
-
-    try:
-        # Load model
-        embedding_model = SentenceTransformer(
-            model_name,
-            cache_folder=cache_dir,
-            local_files_only=True
-        )
-    except Exception as e:
-        PrettyOutput.print(f"Failed to load embedding model: {str(e)}", OutputType.ERROR)
-        os.system(f'huggingface-cli download --repo-type model --local-dir {cache_dir} {model_name}')
-        # Load model
-        embedding_model = SentenceTransformer(
-            model_name,
-            cache_folder=cache_dir,
-            local_files_only=True
-        )
-    
-    return embedding_model
-
-def load_rerank_model():
-    """Load reranking model"""
-    model_name = "BAAI/bge-reranker-v2-m3"
-    cache_dir = os.path.expanduser("~/.cache/huggingface/hub")
-    
-    PrettyOutput.print(f"Loading reranking model: {model_name}...", OutputType.INFO)
-    
-    try:
-        # Load model and tokenizer
-        tokenizer = AutoTokenizer.from_pretrained(
-            model_name,
-            cache_dir=cache_dir,
-            local_files_only=True
-        )
-        model = AutoModelForSequenceClassification.from_pretrained(
-            model_name,
-            cache_dir=cache_dir,
-            local_files_only=True
-        )
-    except Exception as e:
-        PrettyOutput.print(f"Failed to load reranking model: {str(e)}", OutputType.ERROR)
-        os.system(f'huggingface-cli download --repo-type model --local-dir {cache_dir} {model_name}')
-        # Load model and tokenizer
-        tokenizer = AutoTokenizer.from_pretrained(
-            model_name,
-            cache_dir=cache_dir,
-            local_files_only=True
-        )
-        model = AutoModelForSequenceClassification.from_pretrained(
-            model_name,
-            cache_dir=cache_dir,
-            local_files_only=True
-        )
-    
-    # Use GPU if available
-    if torch.cuda.is_available():
-        model = model.cuda()
-    model.eval()
-    
-    return model, tokenizer
 
 def get_max_context_length():
     return int(os.getenv('JARVIS_MAX_CONTEXT_LENGTH', '131072'))  # 默认128k
@@ -359,7 +290,6 @@ def _create_methodology_embedding(embedding_model: Any, methodology_text: str) -
 
 def load_methodology(user_input: str) -> str:
     """Load methodology and build vector index"""
-    PrettyOutput.print("Loading methodology...", OutputType.PROGRESS)
     user_jarvis_methodology = os.path.expanduser("~/.jarvis/methodology")
     if not os.path.exists(user_jarvis_methodology):
         return ""
@@ -368,62 +298,17 @@ def load_methodology(user_input: str) -> str:
         with open(user_jarvis_methodology, "r", encoding="utf-8") as f:
             data = yaml.safe_load(f)
 
-        # Reset data structure
-        methodology_data = []
-        vectors = []
-        ids = []
-
-        # Get embedding model
-        embedding_model = load_embedding_model()
         
-        # Create test embedding to get correct dimension
-        test_embedding = _create_methodology_embedding(embedding_model, "test")
-        embedding_dimension = len(test_embedding)
-
-        # Create embedding vector for each methodology
-        for i, (key, value) in enumerate(data.items()):
-            PrettyOutput.print(f"Vectorizing methodology: {key} ...", OutputType.INFO)
-            methodology_text = f"{key}\n{value}"
-            embedding = _create_methodology_embedding(embedding_model, methodology_text)
-            vectors.append(embedding)
-            ids.append(i)
-            methodology_data.append({"key": key, "value": value})
-
-        if vectors:
-            vectors_array = np.vstack(vectors)
-            # Use correct dimension from test embedding
-            hnsw_index = faiss.IndexHNSWFlat(embedding_dimension, 16)
-            hnsw_index.hnsw.efConstruction = 40
-            hnsw_index.hnsw.efSearch = 16
-            methodology_index = faiss.IndexIDMap(hnsw_index)
-            methodology_index.add_with_ids(vectors_array, np.array(ids)) # type: ignore
-            query_embedding = _create_methodology_embedding(embedding_model, user_input)
-            k = min(5, len(methodology_data))
-            PrettyOutput.print(f"Retrieving methodology...", OutputType.INFO)
-            distances, indices = methodology_index.search(
-                query_embedding.reshape(1, -1), k
-            ) # type: ignore
-
-            relevant_methodologies = {}
-            for dist, idx in zip(distances[0], indices[0]):
-                if idx >= 0:
-                    similarity = 1.0 / (1.0 + float(dist))
-                    methodology = methodology_data[idx]
-                    PrettyOutput.print(
-                        f"Methodology '{methodology['key']}' similarity: {similarity:.3f}",
-                        OutputType.INFO
-                    )
-                    if similarity >= 0.5:
-                        relevant_methodologies[methodology["key"]] = methodology["value"]
-                    
-            if relevant_methodologies:
-                return f"""This is the standard methodology for handling previous problems, if the current task is similar, you can refer to it:
-                        {relevant_methodologies}
-                        """
-        return ""
+        ret = """This is the standard methodology for handling previous problems, if the current task is similar, you can refer to it:"""
+        for k, v in data.items():
+            ret += f"\n{k}: {v}\n"
+        return ret
 
     except Exception as e:
         PrettyOutput.print(f"Error loading methodology: {str(e)}", OutputType.ERROR)
         import traceback
         PrettyOutput.print(f"Error trace: {traceback.format_exc()}", OutputType.INFO)
-        return ""
+        return ""
+    
+def no_embedding() -> bool:
+    return bool(os.environ.get("JARVIS_NO_EMBEDDING", ""))