jarvis-ai-assistant 0.1.126__py3-none-any.whl → 0.1.129__py3-none-any.whl

jarvis/jarvis_utils/config.py

@@ -1,138 +1,174 @@
 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
+配置管理模块
+该模块提供了获取Jarvis系统各种配置设置的函数。
+所有配置都从环境变量中读取，带有回退默认值。
+该模块组织为以下几个类别：
+- 系统配置
+- 模型配置
+- 执行配置
+- 文本处理配置
 """
 def get_max_token_count() -> int:
     """
-    Get the maximum token count for API requests.
+    获取API请求的最大token数量。
     
-    Returns:
-        int: Maximum token count, default is 131072 (128k)
+    返回：
+        int: 最大token数量，默认为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
+    返回：
+        int: 线程数，默认为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
+    返回：
+        bool: 如果不使用本地模型则返回True，默认为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
+    返回：
+        bool: 如果启用了自动补全则返回True，默认为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
+    返回：
+        bool: 如果使用方法论则返回True，默认为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
+    返回：
+        bool: 如果记录方法论则返回True，默认为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
+    返回：
+        bool: 如果需要摘要则返回True，默认为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
+    返回：
+        int: 最小字符长度，默认为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
+    返回：
+        int: 最大字符长度，默认为12800
     """
     return int(os.getenv('JARVIS_MAX_PARAGRAPH_LENGTH', '12800'))
 def get_shell_name() -> str:
     """
-    Get the system shell name.
+    获取系统shell名称。
     
-    Returns:
-        str: Shell name (e.g., bash, zsh), default is bash
+    返回：
+        str: Shell名称（例如bash, zsh），默认为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'
+    返回：
+        str: 平台名称，默认为'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'
+    返回：
+        str: 模型名称，默认为'kimi'
     """
     return os.getenv('JARVIS_MODEL', 'kimi')
 def get_codegen_platform_name() -> str:
+    """
+    获取代码生成的平台名称。
+    
+    返回：
+        str: 平台名称，默认为'kimi'
+    """
     return os.getenv('JARVIS_CODEGEN_PLATFORM', os.getenv('JARVIS_PLATFORM', 'kimi'))
 def get_codegen_model_name() -> str:
+    """
+    获取代码生成的模型名称。
+    
+    返回：
+        str: 模型名称，默认为'kimi'
+    """
     return os.getenv('JARVIS_CODEGEN_MODEL', os.getenv('JARVIS_MODEL', 'kimi'))
 def get_thinking_platform_name() -> str:
+    """
+    获取思考操作的平台名称。
+    
+    返回：
+        str: 平台名称，默认为'kimi'
+    """
     return os.getenv('JARVIS_THINKING_PLATFORM', os.getenv('JARVIS_PLATFORM', 'kimi'))
 def get_thinking_model_name() -> str:
+    """
+    获取思考操作的模型名称。
+    
+    返回：
+        str: 模型名称，默认为'kimi'
+    """
     return os.getenv('JARVIS_THINKING_MODEL', os.getenv('JARVIS_MODEL', 'kimi'))
 def get_cheap_platform_name() -> str:
+    """
+    获取低成本操作的平台名称。
+    
+    返回：
+        str: 平台名称，默认为'kimi'
+    """
     return os.getenv('JARVIS_CHEAP_PLATFORM', os.getenv('JARVIS_PLATFORM', 'kimi'))
 def get_cheap_model_name() -> str:
+    """
+    获取低成本操作的模型名称。
+    
+    返回：
+        str: 模型名称，默认为'kimi'
+    """
     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
+    返回：
+        bool: 如果需要确认则返回True，默认为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
+    返回：
+        bool: 如果需要确认则返回True，默认为False
     """
-    return os.getenv('JARVIS_CONFIRM_BEFORE_APPLY_PATCH', 'false') == 'true'
+    return os.getenv('JARVIS_CONFIRM_BEFORE_APPLY_PATCH', 'false') == 'true'

jarvis/jarvis_utils/embedding.py

@@ -6,35 +6,32 @@ 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.
+    """使用分词器获取文本的token数量。
     
-    Args:
-        text: The input text to count tokens for
+    参数：
+        text: 要计算token的输入文本
         
-    Returns:
-        int: The number of tokens in the text
+    返回：
+        int: 文本中的token数量
     """
     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
+        # 回退到基于字符的粗略估计
+        return len(text) // 4  # 每个token大约4个字符的粗略估计
 
 def load_embedding_model() -> SentenceTransformer:
     """
-    Load the sentence embedding model.
+    加载句子嵌入模型。
     
-    Returns:
-        SentenceTransformer: The loaded embedding model
+    返回：
+        SentenceTransformer: 加载的嵌入模型
     """
     model_name = "BAAI/bge-m3"
     cache_dir = os.path.expanduser("~/.cache/huggingface/hub")
@@ -53,31 +50,33 @@ def load_embedding_model() -> SentenceTransformer:
         )
     
     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
+    参数：
+        embedding_model: 使用的嵌入模型
+        text: 要嵌入的输入文本
         
-    Returns:
-        np.ndarray: The embedding vector
+    返回：
+        np.ndarray: 嵌入向量
     """
     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
+    参数：
+        embedding_model: 使用的嵌入模型
+        texts: 要嵌入的文本列表
         
-    Returns:
-        np.ndarray: Stacked embedding vectors
+    返回：
+        np.ndarray: 堆叠的嵌入向量
     """
     try:
         all_vectors = []
@@ -90,41 +89,41 @@ def get_embedding_batch(embedding_model: Any, texts: List[str]) -> np.ndarray:
         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
+    参数：
+        text: 要分割的输入文本
+        max_length: 每个块的最大长度
         
-    Returns:
-        List[str]: List of text chunks
+    返回：
+        List[str]: 文本块列表
     """
     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
+            if end == start:  # 未找到标点，强制分割
                 end = start + max_length
         chunk = text[start:end]
         chunks.append(chunk)
-        # Overlap 20% of the window
+        # 重叠20%的窗口
         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
+    参数：
+        embedding_model: 使用的嵌入模型
+        text: 要处理的输入文本
         
-    Returns:
-        List[np.ndarray]: List of embedding vectors for each chunk
+    返回：
+        List[np.ndarray]: 每个块的嵌入向量列表
     """
     chunks = split_text_into_chunks(text, 512)
     if not chunks:
@@ -135,12 +134,13 @@ def get_embedding_with_chunks(embedding_model: Any, text: str) -> List[np.ndarra
         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
+    返回：
+        AutoTokenizer: 加载的分词器
     """
     model_name = "gpt2"
     cache_dir = os.path.expanduser("~/.cache/huggingface/hub")
@@ -159,12 +159,13 @@ def load_tokenizer() -> AutoTokenizer:
         )
     
     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
+    返回：
+        Tuple[AutoModelForSequenceClassification, AutoTokenizer]: 加载的模型和分词器
     """
     model_name = "BAAI/bge-reranker-v2-m3"
     cache_dir = os.path.expanduser("~/.cache/huggingface/hub")
@@ -198,4 +199,4 @@ def load_rerank_model() -> Tuple[AutoModelForSequenceClassification, AutoTokeniz
         model = model.cuda()
     model.eval()
     
-    return model, tokenizer # type: ignore
+    return model, tokenizer # type: ignore

jarvis/jarvis_utils/git_utils.py

@@ -1,12 +1,12 @@
 """
-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
+Git工具模块
+该模块提供了与Git仓库交互的工具。
+包含以下功能：
+- 查找Git仓库的根目录
+- 检查是否有未提交的更改
+- 获取两个哈希值之间的提交历史
+- 获取最新提交的哈希值
+- 从Git差异中提取修改的行范围
 """
 import os
 import re
@@ -14,42 +14,42 @@ 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"""
+    """切换到给定路径的Git根目录"""
     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
+    """检查Git仓库中是否有未提交的更改"""
+    # 静默添加所有更改
     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)
+    参数：
+        start_hash: 起始提交哈希值（不包含）
+        end_hash: 结束提交哈希值（包含）
         
-    Returns:
-        List[Tuple[str, str]]: List of (commit_hash, commit_message) tuples
+    返回：
+        List[Tuple[str, str]]: (提交哈希值, 提交信息) 元组列表
     """
     try:
-        # Use git log with pretty format to get hash and message
+        # 使用git log和pretty格式获取哈希值和信息
         result = subprocess.run(
             ['git', 'log', f'{start_hash}..{end_hash}', '--pretty=format:%H|%s'],
             stdout=subprocess.PIPE,
@@ -71,10 +71,10 @@ def get_commits_between(start_hash: str, end_hash: str) -> List[Tuple[str, str]]
         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
+    """获取当前Git仓库的最新提交哈希值
     
-    Returns:
-        str: The commit hash, or empty string if not in a git repo or error occurs
+    返回：
+        str: 提交哈希值，如果不在Git仓库或发生错误则返回空字符串
     """
     try:
         result = subprocess.run(
@@ -89,32 +89,32 @@ def get_latest_commit_hash() -> str:
     except Exception:
         return ""
 def get_modified_line_ranges() -> Dict[str, Tuple[int, int]]:
-    """Get modified line ranges from git diff for all changed files.
+    """从Git差异中获取所有更改文件的修改行范围
     
-    Returns:
-        Dictionary mapping file paths to tuple with (start_line, end_line) ranges
-        for modified sections. Line numbers are 1-based.
+    返回：
+        字典，将文件路径映射到包含修改部分的（起始行, 结束行）范围元组。
+        行号从1开始。
     """
-    # Get git diff for all files
+    # 获取所有文件的Git差异
     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"
+        # 匹配类似"+++ 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
+        # 匹配类似"@@ -100,5 +100,7 @@"的行，其中+部分显示新行
         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
+            start_line = int(range_match.group(1))  # 保持从1开始
             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
+    return result

jarvis/jarvis_utils/globals.py

@@ -1,24 +1,24 @@
 """
-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
+全局变量和配置模块
+该模块管理Jarvis系统的全局状态和配置。
+包含：
+- 全局代理管理
+- 带有自定义主题的控制台配置
+- 环境初始化
 """
 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以支持跨平台的彩色文本
 colorama.init()
-# Disable tokenizers parallelism to avoid issues with multiprocessing
+# 禁用tokenizers并行以避免多进程问题
 os.environ["TOKENIZERS_PARALLELISM"] = "false"
-# Global agent management
+# 全局代理管理
 global_agents: Set[str] = set()
 current_agent_name: str = ""
-# Configure rich console with custom theme
+# 使用自定义主题配置rich控制台
 custom_theme = Theme({
     "INFO": "yellow",
     "WARNING": "yellow",
@@ -36,13 +36,13 @@ custom_theme = Theme({
 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
+    参数：
+        agent_name: 基础代理名称
         
-    Returns:
-        str: Unique agent name
+    返回：
+        str: 唯一的代理名称
     """
     if agent_name in global_agents:
         i = 1
@@ -52,31 +52,31 @@ def make_agent_name(agent_name: str) -> str:
     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
+    参数：
+        agent_name: 代理名称
+        agent: 代理对象
     """
     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
+    返回：
+        str: 包含代理数量和当前代理名称的格式化字符串
     """
     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
+    参数：
+        agent_name: 要删除的代理名称
     """
     if agent_name in global_agents:
         global_agents.remove(agent_name)
         global current_agent_name
-        current_agent_name = ""
+        current_agent_name = ""