jarvis-ai-assistant 0.1.124__py3-none-any.whl → 0.1.125__py3-none-any.whl

jarvis/jarvis_utils/config.py

@@ -0,0 +1,138 @@
+import os
+"""
+Configuration Management Module
+This module provides functions to retrieve various configuration settings for the Jarvis system.
+All configurations are read from environment variables with fallback default values.
+The module is organized into several categories:
+- System Configuration
+- Model Configuration
+- Execution Configuration
+- Text Processing Configuration
+"""
+def get_max_token_count() -> int:
+    """
+    Get the maximum token count for API requests.
+    
+    Returns:
+        int: Maximum token count, default is 131072 (128k)
+    """
+    return int(os.getenv('JARVIS_MAX_TOKEN_COUNT', '131072'))  # 默认128k
+    
+def get_thread_count() -> int:
+    """
+    Get the number of threads to use for parallel processing.
+    
+    Returns:
+        int: Thread count, default is 1
+    """
+    return int(os.getenv('JARVIS_THREAD_COUNT', '1'))  
+def dont_use_local_model() -> bool:
+    """
+    Check if local models should be avoided.
+    
+    Returns:
+        bool: True if local models should not be used, default is False
+    """
+    return os.getenv('JARVIS_DONT_USE_LOCAL_MODEL', 'false') == 'true'
+    
+def is_auto_complete() -> bool:
+    """
+    Check if auto-completion is enabled.
+    
+    Returns:
+        bool: True if auto-completion is enabled, default is False
+    """
+    return os.getenv('JARVIS_AUTO_COMPLETE', 'false') == 'true'
+    
+def is_use_methodology() -> bool:
+    """
+    Check if methodology should be used.
+    
+    Returns:
+        bool: True if methodology should be used, default is True
+    """
+    return os.getenv('JARVIS_USE_METHODOLOGY', 'true') == 'true'
+def is_record_methodology() -> bool:
+    """
+    Check if methodology should be recorded.
+    
+    Returns:
+        bool: True if methodology should be recorded, default is True
+    """
+    return os.getenv('JARVIS_RECORD_METHODOLOGY', 'true') == 'true'
+def is_need_summary() -> bool:
+    """
+    Check if summary generation is required.
+    
+    Returns:
+        bool: True if summary is needed, default is True
+    """
+    return os.getenv('JARVIS_NEED_SUMMARY', 'true') == 'true'
+def get_min_paragraph_length() -> int:
+    """
+    Get the minimum paragraph length for text processing.
+    
+    Returns:
+        int: Minimum length in characters, default is 50
+    """
+    return int(os.getenv('JARVIS_MIN_PARAGRAPH_LENGTH', '50'))
+def get_max_paragraph_length() -> int:
+    """
+    Get the maximum paragraph length for text processing.
+    
+    Returns:
+        int: Maximum length in characters, default is 12800
+    """
+    return int(os.getenv('JARVIS_MAX_PARAGRAPH_LENGTH', '12800'))
+def get_shell_name() -> str:
+    """
+    Get the system shell name.
+    
+    Returns:
+        str: Shell name (e.g., bash, zsh), default is bash
+    """
+    return os.getenv('SHELL', 'bash')
+def get_normal_platform_name() -> str:
+    """
+    Get the platform name for normal operations.
+    
+    Returns:
+        str: Platform name, default is 'kimi'
+    """
+    return os.getenv('JARVIS_PLATFORM', 'kimi')
+def get_normal_model_name() -> str:
+    """
+    Get the model name for normal operations.
+    
+    Returns:
+        str: Model name, default is 'kimi'
+    """
+    return os.getenv('JARVIS_MODEL', 'kimi')
+def get_codegen_platform_name() -> str:
+    return os.getenv('JARVIS_CODEGEN_PLATFORM', os.getenv('JARVIS_PLATFORM', 'kimi'))
+def get_codegen_model_name() -> str:
+    return os.getenv('JARVIS_CODEGEN_MODEL', os.getenv('JARVIS_MODEL', 'kimi'))
+def get_thinking_platform_name() -> str:
+    return os.getenv('JARVIS_THINKING_PLATFORM', os.getenv('JARVIS_PLATFORM', 'kimi'))
+def get_thinking_model_name() -> str:
+    return os.getenv('JARVIS_THINKING_MODEL', os.getenv('JARVIS_MODEL', 'kimi'))
+def get_cheap_platform_name() -> str:
+    return os.getenv('JARVIS_CHEAP_PLATFORM', os.getenv('JARVIS_PLATFORM', 'kimi'))
+def get_cheap_model_name() -> str:
+    return os.getenv('JARVIS_CHEAP_MODEL', os.getenv('JARVIS_MODEL', 'kimi'))
+def is_execute_tool_confirm() -> bool:
+    """
+    Check if tool execution requires confirmation.
+    
+    Returns:
+        bool: True if confirmation is required, default is False
+    """
+    return os.getenv('JARVIS_EXECUTE_TOOL_CONFIRM', 'false') == 'true'
+def is_confirm_before_apply_patch() -> bool:
+    """
+    Check if patch application requires confirmation.
+    
+    Returns:
+        bool: True if confirmation is required, default is False
+    """
+    return os.getenv('JARVIS_CONFIRM_BEFORE_APPLY_PATCH', 'false') == 'true'

jarvis/jarvis_utils/embedding.py

@@ -0,0 +1,201 @@
+import os
+import numpy as np
+import torch
+from sentence_transformers import SentenceTransformer
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+from typing import List, Any, Tuple
+from jarvis.jarvis_utils.output import PrettyOutput, OutputType
+
+
+
+
+def get_context_token_count(text: str) -> int:
+    """Get the token count of the text using the tokenizer.
+    
+    Args:
+        text: The input text to count tokens for
+        
+    Returns:
+        int: The number of tokens in the text
+    """
+    try:
+        # Use a fast tokenizer that's good at general text
+        tokenizer = load_tokenizer()
+        chunks = split_text_into_chunks(text, 512)
+        return sum([len(tokenizer.encode(chunk)) for chunk in chunks]) # type: ignore
+        
+    except Exception as e:
+        PrettyOutput.print(f"计算token失败: {str(e)}", OutputType.WARNING)
+        # Fallback to rough character-based estimate
+        return len(text) // 4  # Rough estimate of 4 chars per token
+
+def load_embedding_model() -> SentenceTransformer:
+    """
+    Load the sentence embedding model.
+    
+    Returns:
+        SentenceTransformer: The loaded embedding model
+    """
+    model_name = "BAAI/bge-m3"
+    cache_dir = os.path.expanduser("~/.cache/huggingface/hub")
+    
+    try:
+        embedding_model = SentenceTransformer(
+            model_name,
+            cache_folder=cache_dir,
+            local_files_only=True
+        )
+    except Exception:
+        embedding_model = SentenceTransformer(
+            model_name,
+            cache_folder=cache_dir,
+            local_files_only=False
+        )
+    
+    return embedding_model
+def get_embedding(embedding_model: Any, text: str) -> np.ndarray:
+    """
+    Generate embedding vector for the given text.
+    
+    Args:
+        embedding_model: The embedding model to use
+        text: The input text to embed
+        
+    Returns:
+        np.ndarray: The embedding vector
+    """
+    embedding = embedding_model.encode(text, 
+                                     normalize_embeddings=True,
+                                     show_progress_bar=False)
+    return np.array(embedding, dtype=np.float32)
+def get_embedding_batch(embedding_model: Any, texts: List[str]) -> np.ndarray:
+    """
+    Generate embeddings for a batch of texts.
+    
+    Args:
+        embedding_model: The embedding model to use
+        texts: List of texts to embed
+        
+    Returns:
+        np.ndarray: Stacked embedding vectors
+    """
+    try:
+        all_vectors = []
+        for text in texts:
+            vectors = get_embedding_with_chunks(embedding_model, text)
+            all_vectors.extend(vectors)
+        return np.vstack(all_vectors)
+    except Exception as e:
+        PrettyOutput.print(f"批量嵌入失败: {str(e)}", OutputType.ERROR)
+        return np.zeros((0, embedding_model.get_sentence_embedding_dimension()), dtype=np.float32)
+    
+def split_text_into_chunks(text: str, max_length: int = 512) -> List[str]:
+    """Split text into chunks with overlapping windows.
+    
+    Args:
+        text: The input text to split
+        max_length: Maximum length of each chunk
+        
+    Returns:
+        List[str]: List of text chunks
+    """
+    chunks = []
+    start = 0
+    while start < len(text):
+        end = start + max_length
+        # Find the nearest sentence boundary
+        if end < len(text):
+            while end > start and text[end] not in {'.', '!', '?', '\n'}:
+                end -= 1
+            if end == start:  # No punctuation found, hard cut
+                end = start + max_length
+        chunk = text[start:end]
+        chunks.append(chunk)
+        # Overlap 20% of the window
+        start = end - int(max_length * 0.2)
+    return chunks
+
+def get_embedding_with_chunks(embedding_model: Any, text: str) -> List[np.ndarray]:
+    """
+    Generate embeddings for text chunks.
+    
+    Args:
+        embedding_model: The embedding model to use
+        text: The input text to process
+        
+    Returns:
+        List[np.ndarray]: List of embedding vectors for each chunk
+    """
+    chunks = split_text_into_chunks(text, 512)
+    if not chunks:
+        return []
+    
+    vectors = []
+    for chunk in chunks:
+        vector = get_embedding(embedding_model, chunk)
+        vectors.append(vector)
+    return vectors
+def load_tokenizer() -> AutoTokenizer:
+    """
+    Load the tokenizer for text processing.
+    
+    Returns:
+        AutoTokenizer: The loaded tokenizer
+    """
+    model_name = "gpt2"
+    cache_dir = os.path.expanduser("~/.cache/huggingface/hub")
+    
+    try:
+        tokenizer = AutoTokenizer.from_pretrained(
+            model_name,
+            cache_dir=cache_dir,
+            local_files_only=True
+        )
+    except Exception:
+        tokenizer = AutoTokenizer.from_pretrained(
+            model_name,
+            cache_dir=cache_dir,
+            local_files_only=False
+        )
+    
+    return tokenizer # type: ignore
+def load_rerank_model() -> Tuple[AutoModelForSequenceClassification, AutoTokenizer]:
+    """
+    Load the reranking model and tokenizer.
+    
+    Returns:
+        Tuple[AutoModelForSequenceClassification, AutoTokenizer]: The loaded model and tokenizer
+    """
+    model_name = "BAAI/bge-reranker-v2-m3"
+    cache_dir = os.path.expanduser("~/.cache/huggingface/hub")
+    
+    PrettyOutput.print(f"加载重排序模型: {model_name}...", OutputType.INFO)
+    
+    try:
+        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:
+        tokenizer = AutoTokenizer.from_pretrained(
+            model_name,
+            cache_dir=cache_dir,
+            local_files_only=False
+        )
+        model = AutoModelForSequenceClassification.from_pretrained(
+            model_name,
+            cache_dir=cache_dir,
+            local_files_only=False
+        )
+    
+    if torch.cuda.is_available():
+        model = model.cuda()
+    model.eval()
+    
+    return model, tokenizer # type: ignore

jarvis/jarvis_utils/git_utils.py

@@ -0,0 +1,120 @@
+"""
+Git Utilities Module
+This module provides utilities for interacting with Git repositories.
+It includes functions for:
+- Finding the root directory of a Git repository
+- Checking for uncommitted changes
+- Retrieving commit history between two hashes
+- Getting the latest commit hash
+- Extracting modified line ranges from Git diffs
+"""
+import os
+import re
+import subprocess
+from typing import List, Tuple, Dict
+from jarvis.jarvis_utils.output import PrettyOutput, OutputType
+def find_git_root(start_dir="."):
+    """Change to git root directory of the given path"""
+    os.chdir(start_dir)
+    git_root = os.popen("git rev-parse --show-toplevel").read().strip()
+    os.chdir(git_root)
+    return git_root
+def has_uncommitted_changes():
+    """Check if there are uncommitted changes in the git repository"""
+    # Add all changes silently
+    subprocess.run(["git", "add", "."], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    
+    # Check working directory changes
+    working_changes = subprocess.run(["git", "diff", "--exit-code"], 
+                                    stdout=subprocess.DEVNULL, 
+                                    stderr=subprocess.DEVNULL).returncode != 0
+    
+    # Check staged changes
+    staged_changes = subprocess.run(["git", "diff", "--cached", "--exit-code"], 
+                                   stdout=subprocess.DEVNULL, 
+                                   stderr=subprocess.DEVNULL).returncode != 0
+    
+    # Reset changes silently
+    subprocess.run(["git", "reset"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    
+    return working_changes or staged_changes
+def get_commits_between(start_hash: str, end_hash: str) -> List[Tuple[str, str]]:
+    """Get list of commits between two commit hashes
+    
+    Args:
+        start_hash: Starting commit hash (exclusive)
+        end_hash: Ending commit hash (inclusive)
+        
+    Returns:
+        List[Tuple[str, str]]: List of (commit_hash, commit_message) tuples
+    """
+    try:
+        # Use git log with pretty format to get hash and message
+        result = subprocess.run(
+            ['git', 'log', f'{start_hash}..{end_hash}', '--pretty=format:%H|%s'],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+        if result.returncode != 0:
+            PrettyOutput.print(f"获取commit历史失败: {result.stderr}", OutputType.ERROR)
+            return []
+            
+        commits = []
+        for line in result.stdout.splitlines():
+            if '|' in line:
+                commit_hash, message = line.split('|', 1)
+                commits.append((commit_hash, message))
+        return commits
+        
+    except Exception as e:
+        PrettyOutput.print(f"获取commit历史异常: {str(e)}", OutputType.ERROR)
+        return []
+def get_latest_commit_hash() -> str:
+    """Get the latest commit hash of the current git repository
+    
+    Returns:
+        str: The commit hash, or empty string if not in a git repo or error occurs
+    """
+    try:
+        result = subprocess.run(
+            ['git', 'rev-parse', 'HEAD'],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+        if result.returncode == 0:
+            return result.stdout.strip()
+        return ""
+    except Exception:
+        return ""
+def get_modified_line_ranges() -> Dict[str, Tuple[int, int]]:
+    """Get modified line ranges from git diff for all changed files.
+    
+    Returns:
+        Dictionary mapping file paths to tuple with (start_line, end_line) ranges
+        for modified sections. Line numbers are 1-based.
+    """
+    # Get git diff for all files
+    diff_output = os.popen("git show").read()
+    
+    # Parse the diff to get modified files and their line ranges
+    result = {}
+    current_file = None
+    
+    for line in diff_output.splitlines():
+        # Match lines like "+++ b/path/to/file"
+        file_match = re.match(r"^\+\+\+ b/(.*)", line)
+        if file_match:
+            current_file = file_match.group(1)
+            continue
+            
+        # Match lines like "@@ -100,5 +100,7 @@" where the + part shows new lines
+        range_match = re.match(r"^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@", line)
+        if range_match and current_file:
+            start_line = int(range_match.group(1))  # Keep as 1-based
+            line_count = int(range_match.group(2)) if range_match.group(2) else 1
+            end_line = start_line + line_count - 1
+            result[current_file] = (start_line, end_line)
+    
+    return result

jarvis/jarvis_utils/globals.py

@@ -0,0 +1,82 @@
+"""
+Global Variables and Configuration Module
+This module manages global state and configurations for the Jarvis system.
+It includes:
+- Global agent management
+- Console configuration with custom theme
+- Environment initialization
+"""
+from typing import Any, Set
+import colorama
+import os
+from rich.console import Console
+from rich.theme import Theme
+# Initialize colorama for cross-platform colored text
+colorama.init()
+# Disable tokenizers parallelism to avoid issues with multiprocessing
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+# Global agent management
+global_agents: Set[str] = set()
+current_agent_name: str = ""
+# Configure rich console with custom theme
+custom_theme = Theme({
+    "INFO": "yellow",
+    "WARNING": "yellow",
+    "ERROR": "red",
+    "SUCCESS": "green",
+    "SYSTEM": "cyan",
+    "CODE": "green",
+    "RESULT": "blue",
+    "PLANNING": "magenta",
+    "PROGRESS": "white",
+    "DEBUG": "blue",
+    "USER": "green",
+    "TOOL": "yellow",
+})
+console = Console(theme=custom_theme)
+def make_agent_name(agent_name: str) -> str:
+    """
+    Generate a unique agent name by appending a suffix if necessary.
+    
+    Args:
+        agent_name: The base agent name
+        
+    Returns:
+        str: Unique agent name
+    """
+    if agent_name in global_agents:
+        i = 1
+        while f"{agent_name}_{i}" in global_agents:
+            i += 1
+        return f"{agent_name}_{i}"
+    return agent_name
+def set_agent(agent_name: str, agent: Any) -> None:
+    """
+    Set the current agent and add it to the global agents set.
+    
+    Args:
+        agent_name: The name of the agent
+        agent: The agent object
+    """
+    global_agents.add(agent_name)
+    global current_agent_name
+    current_agent_name = agent_name
+def get_agent_list() -> str:
+    """
+    Get a formatted string representing the current agent status.
+    
+    Returns:
+        str: Formatted string with agent count and current agent name
+    """
+    return "[" + str(len(global_agents)) + "]" + current_agent_name if global_agents else ""
+def delete_agent(agent_name: str) -> None:
+    """
+    Delete an agent from the global agents set.
+    
+    Args:
+        agent_name: The name of the agent to delete
+    """
+    if agent_name in global_agents:
+        global_agents.remove(agent_name)
+        global current_agent_name
+        current_agent_name = ""

jarvis/jarvis_utils/input.py

@@ -0,0 +1,161 @@
+"""
+Input Handling Module
+This module provides utilities for handling user input in the Jarvis system.
+It includes:
+- Single line input with history support
+- Multi-line input with enhanced completion
+- File path completion with fuzzy matching
+- Custom key bindings for input control
+"""
+from prompt_toolkit import PromptSession
+from prompt_toolkit.styles import Style as PromptStyle
+from prompt_toolkit.formatted_text import FormattedText
+from prompt_toolkit.completion import Completer, Completion, PathCompleter
+from prompt_toolkit.document import Document
+from prompt_toolkit.key_binding import KeyBindings
+from fuzzywuzzy import process
+from colorama import Fore, Style as ColoramaStyle
+from ..jarvis_utils.output import PrettyOutput, OutputType
+def get_single_line_input(tip: str) -> str:
+    """
+    Get single line input with history support.
+    
+    Args:
+        tip: The prompt message to display
+        
+    Returns:
+        str: The user's input
+    """
+    session = PromptSession(history=None)
+    style = PromptStyle.from_dict({
+        'prompt': 'ansicyan',
+    })
+    return session.prompt(f"{tip}", style=style)
+class FileCompleter(Completer):
+    """
+    Custom completer for file paths with fuzzy matching.
+    
+    Attributes:
+        path_completer: Base path completer
+        max_suggestions: Maximum number of suggestions to show
+        min_score: Minimum matching score for suggestions
+    """
+    def __init__(self):
+        """Initialize the file completer with default settings."""
+        self.path_completer = PathCompleter()
+        self.max_suggestions = 10
+        self.min_score = 10
+    def get_completions(self, document: Document, complete_event) -> Completion: # type: ignore
+        """
+        Generate completions for file paths with fuzzy matching.
+        
+        Args:
+            document: The current document being edited
+            complete_event: The completion event
+            
+        Yields:
+            Completion: Suggested completions
+        """
+        text = document.text_before_cursor
+        cursor_pos = document.cursor_position
+        # Find all @ positions in text
+        at_positions = [i for i, char in enumerate(text) if char == '@']
+        if not at_positions:
+            return
+        # Get the last @ position
+        current_at_pos = at_positions[-1]
+        # If cursor is not after the last @, don't complete
+        if cursor_pos <= current_at_pos:
+            return
+        # Check if there's a space after @
+        text_after_at = text[current_at_pos + 1:cursor_pos]
+        if ' ' in text_after_at:
+            return
+        # Get the text after the current @
+        file_path = text_after_at.strip()
+        # Calculate replacement length
+        replace_length = len(text_after_at) + 1
+        # Get all possible files using git ls-files
+        all_files = []
+        try:
+            import subprocess
+            result = subprocess.run(['git', 'ls-files'], 
+                                 stdout=subprocess.PIPE, 
+                                 stderr=subprocess.PIPE,
+                                 text=True)
+            if result.returncode == 0:
+                all_files = [line.strip() for line in result.stdout.splitlines() if line.strip()]
+        except Exception:
+            pass
+        # Generate completions
+        if not file_path:
+            scored_files = [(path, 100) for path in all_files[:self.max_suggestions]]
+        else:
+            scored_files_data = process.extract(file_path, all_files, limit=self.max_suggestions)
+            scored_files = [(m[0], m[1]) for m in scored_files_data]
+            scored_files.sort(key=lambda x: x[1], reverse=True)
+            scored_files = scored_files[:self.max_suggestions]
+        # Yield completions
+        for path, score in scored_files:
+            if not file_path or score > self.min_score:
+                display_text = path
+                if file_path and score < 100:
+                    display_text = f"{path} ({score}%)"
+                yield Completion(
+                    text=f"'{path}'",
+                    start_position=-replace_length,
+                    display=display_text,
+                    display_meta="File"
+                ) # type: ignore
+def get_multiline_input(tip: str) -> str:
+    """
+    Get multi-line input with enhanced completion and confirmation.
+    
+    Args:
+        tip: The prompt message to display
+        
+    Returns:
+        str: The user's input, or empty string if canceled
+    """
+    # Display input instructions
+    PrettyOutput.section("用户输入 - 使用 @ 触发文件补全，Tab 选择补全项，Ctrl+J 提交，按 Ctrl+C 取消输入", OutputType.USER)
+    print(f"{Fore.GREEN}{tip}{ColoramaStyle.RESET_ALL}")
+    # Configure key bindings
+    bindings = KeyBindings()
+    @bindings.add('enter')
+    def _(event):
+        """Handle enter key for completion or new line."""
+        if event.current_buffer.complete_state:
+            event.current_buffer.apply_completion(event.current_buffer.complete_state.current_completion)
+        else:
+            event.current_buffer.insert_text('\n')
+    @bindings.add('c-j')
+    def _(event):
+        """Handle Ctrl+J for submission."""
+        event.current_buffer.validate_and_handle()
+    # Configure prompt session
+    style = PromptStyle.from_dict({
+        'prompt': 'ansicyan',
+    })
+    try:
+        session = PromptSession(
+            history=None,
+            completer=FileCompleter(),
+            key_bindings=bindings,
+            complete_while_typing=True,
+            multiline=True,
+            vi_mode=False,
+            mouse_support=False
+        )
+        prompt = FormattedText([
+            ('class:prompt', '>>> ')
+        ])
+        # Get input
+        text = session.prompt(
+            prompt,
+            style=style,
+        ).strip()
+        return text
+    except KeyboardInterrupt:
+        PrettyOutput.print("输入已取消", OutputType.INFO)
+        return ""