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

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

jarvis/jarvis_utils/methodology.py

@@ -1,11 +1,11 @@
 """
-Methodology Management Module
-This module provides utilities for loading and searching methodologies.
-It includes functions for:
-- Creating methodology embeddings
-- Loading and processing methodology data
-- Building and searching methodology index
-- Generating methodology prompts
+方法论管理模块
+该模块提供了加载和搜索方法论的实用工具。
+包含以下功能：
+- 创建方法论嵌入向量
+- 加载和处理方法论数据
+- 构建和搜索方法论索引
+- 生成方法论提示
 """
 import os
 import yaml
@@ -17,17 +17,17 @@ from jarvis.jarvis_utils.embedding import load_embedding_model
 from jarvis.jarvis_utils.config import dont_use_local_model
 def _create_methodology_embedding(embedding_model: Any, methodology_text: str) -> np.ndarray:
     """
-    Create embedding vector for methodology text.
+    为方法论文本创建嵌入向量。
     
-    Args:
-        embedding_model: The embedding model to use
-        methodology_text: The text to create embedding for
+    参数：
+        embedding_model: 使用的嵌入模型
+        methodology_text: 要创建嵌入的文本
         
-    Returns:
-        np.ndarray: The embedding vector
+    返回：
+        np.ndarray: 嵌入向量
     """
     try:
-        # Truncate long text
+        # 截断长文本
         max_length = 512
         text = ' '.join(methodology_text.split()[:max_length])
         
@@ -36,7 +36,7 @@ def _create_methodology_embedding(embedding_model: Any, methodology_text: str) -
                                           convert_to_tensor=True,
                                           normalize_embeddings=True)
         vector = np.array(embedding.cpu().numpy(), dtype=np.float32)
-        return vector[0]  # Return first vector, because we only encoded one text
+        return vector[0]  # 返回第一个向量，因为我们只编码了一个文本
     except Exception as e:
         PrettyOutput.print(f"创建方法论嵌入向量失败: {str(e)}", OutputType.ERROR)
         return np.zeros(1536, dtype=np.float32)
@@ -44,85 +44,103 @@ def make_methodology_prompt(data: Dict[str, str]) -> str:
     """
     从方法论数据生成格式化提示
     
-    Args:
+    参数：
         data: 方法论数据字典
         
-    Returns:
+    返回：
         str: 格式化后的提示字符串
     """
     ret = """这是处理以往问题的标准方法论，如果当前任务类似，可以参考使用，如果不相关，请忽略：\n""" 
     for key, value in data.items():
         ret += f"问题: {key}\n方法论: {value}\n"
     return ret
+
 def load_methodology(user_input: str) -> str:
     """
-    Load methodology and build vector index for similarity search.
+    加载方法论并构建向量索引以进行相似性搜索。
     
-    Args:
-        user_input: The input text to search methodologies for
+    参数：
+        user_input: 要搜索方法论的输入文本
         
-    Returns:
-        str: Relevant methodology prompt or empty string if no methodology found
+    返回：
+        str: 相关的方法论提示，如果未找到方法论则返回空字符串
     """
-    PrettyOutput.print("加载方法论...", OutputType.PROGRESS)
+    from yaspin import yaspin
     user_jarvis_methodology = os.path.expanduser("~/.jarvis/methodology")
     if not os.path.exists(user_jarvis_methodology):
         return ""
     
     try:
-        with open(user_jarvis_methodology, "r", encoding="utf-8") as f:
-            data = yaml.safe_load(f)
-        if dont_use_local_model():
-            return make_methodology_prompt(data)
-        # Reset data structure
-        methodology_data: List[Dict[str, str]] = []
-        vectors: List[np.ndarray] = []
-        ids: List[int] = []
-        # Get embedding model
-        embedding_model = load_embedding_model()
+        with yaspin(text="加载方法论文件...", color="yellow") as spinner:
+            with open(user_jarvis_methodology, "r", encoding="utf-8") as f:
+                data = yaml.safe_load(f)
+            if dont_use_local_model():
+                spinner.text = "加载方法论文件完成"
+                spinner.ok("✅")
+                return make_methodology_prompt(data)
         
-        # 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()):
-            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(3, len(methodology_data))
-            PrettyOutput.print(f"检索方法论...", OutputType.INFO)
-            distances, indices = methodology_index.search(
-                query_embedding.reshape(1, -1), k
-            ) # type: ignore
-            relevant_methodologies = {}
-            output_lines = []
-            for dist, idx in zip(distances[0], indices[0]):
-                if idx >= 0:
-                    similarity = 1.0 / (1.0 + float(dist))
-                    methodology = methodology_data[idx]
-                    output_lines.append(
-                        f"Methodology '{methodology['key']}' similarity: {similarity:.3f}"
-                    )
-                    if similarity >= 0.5:
-                        relevant_methodologies[methodology["key"]] = methodology["value"]
+        with yaspin(text="初始化数据结构...", color="yellow") as spinner:
+            methodology_data: List[Dict[str, str]] = []
+            vectors: List[np.ndarray] = []
+            ids: List[int] = []
+            spinner.text = "初始化数据结构完成"
+            spinner.ok("✅")
+            
+            with yaspin(text="加载嵌入模型...", color="yellow") as spinner:
+                embedding_model = load_embedding_model()
+                spinner.text = "加载嵌入模型完成"
+                spinner.ok("✅")
+            
+            with yaspin(text="创建测试嵌入...", color="yellow") as spinner:
+                test_embedding = _create_methodology_embedding(embedding_model, "test")
+                embedding_dimension = len(test_embedding)
+                spinner.text = "创建测试嵌入完成"
+                spinner.ok("✅")
             
-            if output_lines:
-                PrettyOutput.print("\n".join(output_lines), OutputType.INFO)
-                    
-            if relevant_methodologies:
-                return make_methodology_prompt(relevant_methodologies)
-        return make_methodology_prompt(data)
+            with yaspin(text="处理方法论数据...", color="yellow") as spinner:
+                for i, (key, value) in enumerate(data.items()):
+                    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})
+                spinner.text = "处理方法论数据完成"
+                spinner.ok("✅")
+            
+            if vectors:
+                with yaspin(text="构建索引...", color="yellow") as spinner:
+                    vectors_array = np.vstack(vectors)
+                    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
+                    spinner.text = "构建索引完成"
+                    spinner.ok("✅")
+                
+                with yaspin(text="执行搜索...", color="yellow") as spinner:
+                    query_embedding = _create_methodology_embedding(embedding_model, user_input)
+                    k = min(3, len(methodology_data))
+                    distances, indices = methodology_index.search(
+                        query_embedding.reshape(1, -1), k
+                    ) # type: ignore
+                    spinner.text = "执行搜索完成"
+                    spinner.ok("✅")
+                
+                with yaspin(text="处理搜索结果...", color="yellow") as spinner:
+                    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]
+                            if similarity >= 0.5:
+                                relevant_methodologies[methodology["key"]] = methodology["value"]
+                    spinner.text = "处理搜索结果完成"
+                    spinner.ok("✅")
+
+                
+                if relevant_methodologies:
+                    return make_methodology_prompt(relevant_methodologies)
+            return make_methodology_prompt(data)
     except Exception as e:
-        PrettyOutput.print(f"加载方法论失败: {str(e)}", OutputType.ERROR)
-        return ""
+        return ""

jarvis/jarvis_utils/output.py

@@ -1,11 +1,11 @@
 """
-Output Formatting Module
-This module provides rich text formatting and display utilities for the Jarvis system.
-It includes:
-- OutputType enum for categorizing different types of output
-- PrettyOutput class for formatting and displaying styled output
-- Syntax highlighting support for various programming languages
-- Panel-based display for structured output
+输出格式化模块
+该模块为Jarvis系统提供了丰富的文本格式化和显示工具。
+包含：
+- 用于分类不同输出类型的OutputType枚举
+- 用于格式化和显示样式化输出的PrettyOutput类
+- 多种编程语言的语法高亮支持
+- 结构化输出的面板显示
 """
 from enum import Enum
 from datetime import datetime
@@ -20,21 +20,21 @@ from pygments.util import ClassNotFound
 from .globals import console, get_agent_list
 class OutputType(Enum):
     """
-    Enumeration of output types for categorizing and styling different types of messages.
+    输出类型枚举，用于分类和样式化不同类型的消息。
     
-    Attributes:
-        SYSTEM: AI assistant message
-        CODE: Code related output
-        RESULT: Tool execution result
-        ERROR: Error information
-        INFO: System prompt
-        PLANNING: Task planning
-        PROGRESS: Execution progress
-        SUCCESS: Success information
-        WARNING: Warning information
-        DEBUG: Debug information
-        USER: User input
-        TOOL: Tool call
+    属性：
+        SYSTEM: AI助手消息
+        CODE: 代码相关输出
+        RESULT: 工具执行结果
+        ERROR: 错误信息
+        INFO: 系统提示
+        PLANNING: 任务规划
+        PROGRESS: 执行进度
+        SUCCESS: 成功信息
+        WARNING: 警告信息
+        DEBUG: 调试信息
+        USER: 用户输入
+        TOOL: 工具调用
     """
     SYSTEM = "SYSTEM"
     CODE = "CODE"
@@ -50,15 +50,15 @@ class OutputType(Enum):
     TOOL = "TOOL"
 class PrettyOutput:
     """
-    Class for formatting and displaying rich text output using the rich library.
+    使用rich库格式化和显示富文本输出的类。
     
-    Provides methods for:
-    - Formatting different types of output with appropriate styling
-    - Syntax highlighting for code blocks
-    - Panel-based display for structured content
-    - Stream output for progressive display
+    提供以下方法：
+    - 使用适当的样式格式化不同类型的输出
+    - 代码块的语法高亮
+    - 结构化内容的面板显示
+    - 渐进显示的流式输出
     """
-    # Icons for different output types
+    # 不同输出类型的图标
     _ICONS = {
         OutputType.SYSTEM: "🤖",
         OutputType.CODE: "📝",
@@ -73,7 +73,7 @@ class PrettyOutput:
         OutputType.USER: "👤",
         OutputType.TOOL: "🔧",
     }
-    # Language mapping for syntax highlighting
+    # 语法高亮的语言映射
     _lang_map = {
         'Python': 'python',
         'JavaScript': 'javascript',
@@ -109,14 +109,14 @@ class PrettyOutput:
     @staticmethod
     def _detect_language(text: str, default_lang: str = 'markdown') -> str:
         """
-        Detect the programming language of the given text.
+        检测给定文本的编程语言。
         
-        Args:
-            text: The text to analyze
-            default_lang: Default language if detection fails
+        参数：
+            text: 要分析的文本
+            default_lang: 如果检测失败，默认返回的语言
             
-        Returns:
-            str: Detected language name
+        返回：
+            str: 检测到的语言名称
         """
         try:
             lexer = guess_lexer(text)
@@ -127,14 +127,14 @@ class PrettyOutput:
     @staticmethod
     def _format(output_type: OutputType, timestamp: bool = True) -> Text:
         """
-        Format the output header with timestamp and icon.
+        使用时间戳和图标格式化输出头。
         
-        Args:
-            output_type: Type of output
-            timestamp: Whether to include timestamp
+        参数：
+            output_type: 输出类型
+            timestamp: 是否包含时间戳
             
-        Returns:
-            Text: Formatted rich Text object
+        返回：
+            Text: 格式化后的rich Text对象
         """
         formatted = Text()
         if timestamp:
@@ -148,14 +148,14 @@ class PrettyOutput:
     @staticmethod
     def print(text: str, output_type: OutputType, timestamp: bool = True, lang: Optional[str] = None, traceback: bool = False):
         """
-        Print formatted output with styling and syntax highlighting.
+        使用样式和语法高亮打印格式化输出。
         
-        Args:
-            text: The text content to print
-            output_type: The type of output (affects styling)
-            timestamp: Whether to show timestamp
-            lang: Language for syntax highlighting
-            traceback: Whether to show traceback for errors
+        参数：
+            text: 要打印的文本内容
+            output_type: 输出类型（影响样式）
+            timestamp: 是否显示时间戳
+            lang: 语法高亮的语言
+            traceback: 是否显示错误的回溯信息
         """
         styles = {
             OutputType.SYSTEM: RichStyle(color="bright_cyan", bgcolor="#1a1a1a", frame=True, meta={"icon": "🤖"}),
@@ -184,17 +184,18 @@ class PrettyOutput:
             highlight=True,
             box=HEAVY,
         )
+        console.print()
         console.print(panel)
         if traceback or output_type == OutputType.ERROR:
             console.print_exception()
     @staticmethod
     def section(title: str, output_type: OutputType = OutputType.INFO):
         """
-        Print a section title in a styled panel.
+        在样式化面板中打印章节标题。
         
-        Args:
-            title: The section title text
-            output_type: The type of output (affects styling)
+        参数：
+            title: 章节标题文本
+            output_type: 输出类型（影响样式）
         """
         panel = Panel(
             Text(title, style=output_type.value, justify="center"),
@@ -206,17 +207,17 @@ class PrettyOutput:
     @staticmethod
     def print_stream(text: str):
         """
-        Print stream output without line break.
+        打印流式输出，不带换行符。
         
-        Args:
-            text: The text to print
+        参数：
+            text: 要打印的文本
         """
         style = PrettyOutput._get_style(OutputType.SYSTEM)
         console.print(text, style=style, end="")
     @staticmethod
     def print_stream_end():
         """
-        End stream output with line break.
+        结束流式输出，带换行符。
         """
         end_style = PrettyOutput._get_style(OutputType.SUCCESS)
         console.print("\n", style=end_style)
@@ -224,12 +225,12 @@ class PrettyOutput:
     @staticmethod
     def _get_style(output_type: OutputType) -> RichStyle:
         """
-        Get pre-defined RichStyle for output type.
+        获取预定义的RichStyle用于输出类型。
         
-        Args:
-            output_type: The output type to get style for
+        参数：
+            output_type: 要获取样式的输出类型
             
-        Returns:
-            RichStyle: The corresponding style
+        返回：
+            RichStyle: 对应的样式
         """
-        return console.get_style(output_type.value)
+        return console.get_style(output_type.value)

jarvis/jarvis_utils/utils.py

@@ -130,7 +130,7 @@ def init_gpu_config() -> Dict:
 
 
 def is_long_context(files: list) -> bool:
-    """Check if the file list belongs to a long context (total characters exceed 80% of the maximum context length)"""
+    """检查文件列表是否属于长上下文（总字符数超过最大上下文长度的80%）"""
     max_token_count = get_max_token_count()
     threshold = max_token_count * 0.8
     total_tokens = 0
@@ -147,4 +147,4 @@ def is_long_context(files: list) -> bool:
             PrettyOutput.print(f"读取文件 {file_path} 失败: {e}", OutputType.WARNING)
             continue
             
-    return total_tokens > threshold
+    return total_tokens > threshold

{jarvis_ai_assistant-0.1.126.dist-info → jarvis_ai_assistant-0.1.129.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jarvis-ai-assistant
-Version: 0.1.126
+Version: 0.1.129
 Summary: Jarvis: An AI assistant that uses tools to interact with the system
 Home-page: https://github.com/skyfireitdiy/Jarvis
 Author: skyfire