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

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 = ""

jarvis/jarvis_utils/input.py

@@ -1,11 +1,11 @@
 """
-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
+输入处理模块
+该模块提供了处理Jarvis系统中用户输入的实用工具。
+包含：
+- 支持历史记录的单行输入
+- 增强补全功能的多行输入
+- 带有模糊匹配的文件路径补全
+- 用于输入控制的自定义键绑定
 """
 from prompt_toolkit import PromptSession
 from prompt_toolkit.styles import Style as PromptStyle
@@ -18,13 +18,13 @@ 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
+    参数：
+        tip: 要显示的提示信息
         
-    Returns:
-        str: The user's input
+    返回：
+        str: 用户的输入
     """
     session = PromptSession(history=None)
     style = PromptStyle.from_dict({
@@ -33,49 +33,65 @@ def get_single_line_input(tip: str) -> str:
     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
+    属性：
+        path_completer: 基础路径补全器
+        max_suggestions: 显示的最大建议数量
+        min_score: 建议的最小匹配分数
     """
     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
+        参数：
+            document: 当前正在编辑的文档
+            complete_event: 补全事件
             
-        Yields:
-            Completion: Suggested completions
+        生成：
+            Completion: 建议的补全项
         """
         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 @
+        # 添加默认建议
+        if not text_after_at.strip():
+            # 默认建议列表
+            default_suggestions = [
+                ('<CodeBase>', '查询代码库'),
+                ('<Web>', '网页搜索'),
+                ('<RAG>', '知识库检索')
+            ]
+            for name, desc in default_suggestions:
+                yield Completion(
+                    text=f"'{name}'",
+                    start_position=-1,
+                    display=name,
+                    display_meta=desc
+                ) # type: ignore
+            return
+        # 获取当前@之后的文本
         file_path = text_after_at.strip()
-        # Calculate replacement length
+        # 计算替换长度
         replace_length = len(text_after_at) + 1
-        # Get all possible files using git ls-files
+        # 使用git ls-files获取所有可能的文件
         all_files = []
         try:
             import subprocess
@@ -87,7 +103,7 @@ class FileCompleter(Completer):
                 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:
@@ -95,7 +111,7 @@ class FileCompleter(Completer):
             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
@@ -109,31 +125,31 @@ class FileCompleter(Completer):
                 ) # 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
+    参数：
+        tip: 要显示的提示信息
         
-    Returns:
-        str: The user's input, or empty string if canceled
+    返回：
+        str: 用户的输入，如果取消则返回空字符串
     """
-    # 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."""
+        """处理Ctrl+J以提交输入。"""
         event.current_buffer.validate_and_handle()
-    # Configure prompt session
+    # 配置提示会话
     style = PromptStyle.from_dict({
         'prompt': 'ansicyan',
     })
@@ -150,7 +166,7 @@ def get_multiline_input(tip: str) -> str:
         prompt = FormattedText([
             ('class:prompt', '>>> ')
         ])
-        # Get input
+        # 获取输入
         text = session.prompt(
             prompt,
             style=style,
@@ -158,4 +174,4 @@ def get_multiline_input(tip: str) -> str:
         return text
     except KeyboardInterrupt:
         PrettyOutput.print("输入已取消", OutputType.INFO)
-        return ""
+        return ""