jarvis-ai-assistant 0.1.172__tar.gz → 0.1.174__tar.gz

{jarvis_ai_assistant-0.1.172/src/jarvis_ai_assistant.egg-info → jarvis_ai_assistant-0.1.174}/PKG-INFO

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

{jarvis_ai_assistant-0.1.172 → jarvis_ai_assistant-0.1.174}/pyproject.toml

@@ -8,7 +8,7 @@ default = true
 
 [project]
 name = "jarvis-ai-assistant"
-version = "0.1.172"
+version = "0.1.174"
 description = "Jarvis: An AI assistant that uses tools to interact with the system"
 readme = "README.md"
 authors = [{ name = "skyfire", email = "skyfireitdiy@hotmail.com" }]

{jarvis_ai_assistant-0.1.172 → jarvis_ai_assistant-0.1.174}/setup.py

@@ -3,7 +3,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="jarvis-ai-assistant",
-    version="0.1.172",
+    version="0.1.174",
     author="skyfire",
     author_email="skyfireitdiy@hotmail.com",
     description="An AI assistant that uses various tools to interact with the system",

{jarvis_ai_assistant-0.1.172 → jarvis_ai_assistant-0.1.174}/src/jarvis/__init__.py

@@ -1,4 +1,4 @@
 # -*- coding: utf-8 -*-
 """Jarvis AI Assistant"""
 
-__version__ = "0.1.172"
+__version__ = "0.1.174"

{jarvis_ai_assistant-0.1.172 → jarvis_ai_assistant-0.1.174}/src/jarvis/jarvis_platform/base.py

@@ -48,7 +48,6 @@ class BasePlatform(ABC):
         start_time = time.time()
 
         input_token_count = get_context_token_count(message)
-
         if is_context_overflow(message):
             PrettyOutput.print("错误：输入内容超过最大限制", OutputType.WARNING)
             return "错误：输入内容超过最大限制"
@@ -56,10 +55,12 @@ class BasePlatform(ABC):
         if input_token_count > get_max_input_token_count():
             current_suppress_output = self.suppress_output
             self.set_suppress_output(True)
-            inputs = split_text_into_chunks(message, get_max_input_token_count() - 1024, get_max_input_token_count() - 2048)
+            max_chunk_size = get_max_input_token_count() - 1024  # 留出一些余量
+            min_chunk_size = max_chunk_size // 2  # 最小块大小设为最大块大小的一半
+            inputs = split_text_into_chunks(message, max_chunk_size, min_chunk_size)
             with yaspin(text="正在提交长上下文...", color="cyan") as spinner:
                 prefix_prompt = f"""
-                我将分多次提供大量内容，在我明确告诉你内容已经全部提供完毕之前，每次仅需要输出“已收到”，明白请输出“开始接收输入”。
+                我将分多次提供大量内容，在我明确告诉你内容已经全部提供完毕之前，每次仅需要输出"已收到"，明白请输出"开始接收输入"。
                 """
                 while_true(lambda: while_success(lambda: self.chat(prefix_prompt), 5), 5)
                 submit_count = 0

{jarvis_ai_assistant-0.1.172 → jarvis_ai_assistant-0.1.174}/src/jarvis/jarvis_tools/cli/main.py

@@ -6,7 +6,26 @@ from jarvis.jarvis_utils.utils import init_env
 
 
 def main() -> int:
-    """命令行工具入口，提供工具列表查看和工具调用功能"""
+    """
+    命令行工具入口，提供工具列表查看和工具调用功能
+    
+    功能:
+        1. 列出所有可用工具 (list命令)
+        2. 调用指定工具 (call命令)
+    
+    参数:
+        通过命令行参数传递，包括:
+        - list: 列出工具
+            --json: 以JSON格式输出
+            --detailed: 显示详细信息
+        - call: 调用工具
+            tool_name: 工具名称
+            --args: 工具参数(JSON格式)
+            --args-file: 从文件加载工具参数
+    
+    返回值:
+        int: 0表示成功，非0表示错误
+    """
     import argparse
     import json
 
@@ -34,24 +53,24 @@ def main() -> int:
     registry = ToolRegistry()
 
     if args.command == "list":
-        tools = registry.get_all_tools()
+        tools = registry.get_all_tools()  # 从注册表获取所有工具信息
 
         if args.json:
             if args.detailed:
-                print(json.dumps(tools, indent=2, ensure_ascii=False))
+                print(json.dumps(tools, indent=2, ensure_ascii=False))  # 输出完整JSON格式
             else:
                 simple_tools = [
                     {"name": t["name"], "description": t["description"]} for t in tools
-                ]
+                ]  # 简化工具信息
                 print(json.dumps(simple_tools, indent=2, ensure_ascii=False))
         else:
-            PrettyOutput.section("可用工具列表", OutputType.SYSTEM)
+            PrettyOutput.section("可用工具列表", OutputType.SYSTEM)  # 使用美化输出
             for tool in tools:
                 print(f"\n✅ {tool['name']}")
                 print(f"   描述: {tool['description']}")
                 if args.detailed:
                     print(f"   参数:")
-                    print(tool["parameters"])
+                    print(tool["parameters"])  # 显示详细参数信息
 
     elif args.command == "call":
         tool_name = args.tool_name
@@ -63,11 +82,11 @@ def main() -> int:
             print(f"可用工具: {available_tools}")
             return 1
 
-        # 获取参数
+        # 获取参数: 支持从命令行直接传入或从文件加载
         tool_args = {}
         if args.args:
             try:
-                tool_args = json.loads(args.args)
+                tool_args = json.loads(args.args)  # 解析JSON格式参数
             except json.JSONDecodeError:
                 PrettyOutput.print("错误: 参数必须是有效的JSON格式", OutputType.ERROR)
                 return 1
@@ -75,14 +94,14 @@ def main() -> int:
         elif args.args_file:
             try:
                 with open(args.args_file, "r", encoding="utf-8") as f:
-                    tool_args = json.load(f)
+                    tool_args = json.load(f)  # 从文件加载JSON参数
             except (json.JSONDecodeError, FileNotFoundError) as e:
                 PrettyOutput.print(
                     f"错误: 无法从文件加载参数: {str(e)}", OutputType.ERROR
                 )
                 return 1
 
-        # 检查必需参数
+        # 检查必需参数是否完整
         required_params = tool_obj.parameters.get("required", [])
         missing_params = [p for p in required_params if p not in tool_args]
 
@@ -98,10 +117,10 @@ def main() -> int:
                 print(f"  - {param_name}: {desc}")
             return 1
 
-        # 执行工具
+        # 执行工具并处理结果
         result = registry.execute_tool(tool_name, tool_args)
 
-        # 显示结果
+        # 显示执行结果
         if result["success"]:
             PrettyOutput.section(f"工具 {tool_name} 执行成功", OutputType.SUCCESS)
         else:

{jarvis_ai_assistant-0.1.172 → jarvis_ai_assistant-0.1.174}/src/jarvis/jarvis_utils/config.py

@@ -160,4 +160,4 @@ def get_max_big_content_size() -> int:
     返回：
         int: 最大大内容大小，默认为1MB
     """
-    return int(os.getenv('JARVIS_MAX_BIG_CONTENT_SIZE', '163840'))
+    return int(os.getenv('JARVIS_MAX_BIG_CONTENT_SIZE', '96000'))

jarvis_ai_assistant-0.1.174/src/jarvis/jarvis_utils/embedding.py

@@ -0,0 +1,122 @@
+# -*- coding: utf-8 -*-
+import os
+from transformers import AutoTokenizer
+from typing import List
+import functools
+
+from jarvis.jarvis_utils.output import PrettyOutput, OutputType
+from jarvis.jarvis_utils.config import get_data_dir
+
+# 全局缓存，避免重复加载模型
+_global_tokenizers = {}
+
+def get_context_token_count(text: str) -> int:
+    """使用分词器获取文本的token数量。
+
+    参数：
+        text: 要计算token的输入文本
+
+    返回：
+        int: 文本中的token数量
+    """
+    try:
+        tokenizer = load_tokenizer()
+        # 分批处理长文本，确保不超过模型最大长度
+        total_tokens = 0
+        chunk_size = 100  # 每次处理100个字符，避免超过模型最大长度（考虑到中文字符可能被编码成多个token）
+        for i in range(0, len(text), chunk_size):
+            chunk = text[i:i + chunk_size]
+            tokens = tokenizer.encode(chunk)  # type: ignore
+            total_tokens += len(tokens)
+        return total_tokens
+    except Exception as e:
+        PrettyOutput.print(f"计算token失败: {str(e)}", OutputType.WARNING)
+        return len(text) // 4  # 每个token大约4个字符的粗略估计
+
+def split_text_into_chunks(text: str, max_length: int = 512, min_length: int = 50) -> List[str]:
+    """将文本分割成块，基于token数量进行切割。
+
+    参数：
+        text: 要分割的输入文本
+        max_length: 每个块的最大token数量
+        min_length: 每个块的最小token数量（除了最后一块可能较短）
+
+    返回：
+        List[str]: 文本块列表，每个块的token数量不超过max_length且不小于min_length
+    """
+    if not text:
+        return []
+
+    try:
+        chunks = []
+        current_chunk = ""
+        current_tokens = 0
+        
+        # 按较大的块处理文本，避免破坏token边界
+        chunk_size = 50  # 每次处理50个字符
+        for i in range(0, len(text), chunk_size):
+            chunk = text[i:i + chunk_size]
+            chunk_tokens = get_context_token_count(chunk)
+            
+            # 如果当前块加上新块会超过最大长度，且当前块已经达到最小长度，则保存当前块
+            if current_tokens + chunk_tokens > max_length and current_tokens >= min_length:
+                chunks.append(current_chunk)
+                current_chunk = chunk
+                current_tokens = chunk_tokens
+            else:
+                current_chunk += chunk
+                current_tokens += chunk_tokens
+
+        # 处理最后一个块
+        if current_chunk:
+            if current_tokens >= min_length:
+                chunks.append(current_chunk)
+            elif chunks:  # 如果最后一个块太短，尝试与前面的块合并
+                last_chunk = chunks[-1]
+                combined = last_chunk + current_chunk
+                combined_tokens = get_context_token_count(combined)
+                if combined_tokens <= max_length:
+                    chunks[-1] = combined
+                else:
+                    chunks.append(current_chunk)
+
+        return chunks
+
+    except Exception as e:
+        PrettyOutput.print(f"文本分割失败: {str(e)}", OutputType.WARNING)
+        # 发生错误时回退到简单的字符分割
+        return [text[i:i + max_length] for i in range(0, len(text), max_length)]
+
+
+@functools.lru_cache(maxsize=1)
+def load_tokenizer() -> AutoTokenizer:
+    """
+    加载用于文本处理的分词器，使用缓存避免重复加载。
+
+    返回：
+        AutoTokenizer: 加载的分词器
+    """
+    model_name = "gpt2"
+    cache_dir = os.path.join(get_data_dir(), "huggingface", "hub")
+
+    # 检查全局缓存
+    if model_name in _global_tokenizers:
+        return _global_tokenizers[model_name]
+
+    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
+        )
+
+    # 保存到全局缓存
+    _global_tokenizers[model_name] = tokenizer
+
+    return tokenizer # type: ignore

{jarvis_ai_assistant-0.1.172 → jarvis_ai_assistant-0.1.174/src/jarvis_ai_assistant.egg-info}/PKG-INFO

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

jarvis_ai_assistant-0.1.172/src/jarvis/jarvis_utils/embedding.py

@@ -1,181 +0,0 @@
-# -*- coding: utf-8 -*-
-import os
-from transformers import AutoTokenizer
-from typing import List
-import functools
-
-from jarvis.jarvis_utils.output import PrettyOutput, OutputType
-from jarvis.jarvis_utils.config import get_data_dir
-
-# 全局缓存，避免重复加载模型
-_global_tokenizers = {}
-
-def get_context_token_count(text: str) -> int:
-    """使用分词器获取文本的token数量。
-
-    参数：
-        text: 要计算token的输入文本
-
-    返回：
-        int: 文本中的token数量
-    """
-    try:
-        # 使用擅长处理通用文本的快速分词器
-        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)
-        # 回退到基于字符的粗略估计
-        return len(text) // 4  # 每个token大约4个字符的粗略估计
-
-def split_text_into_chunks(text: str, max_length: int = 512, min_length: int = 50) -> List[str]:
-    """将文本分割成带重叠窗口的块，优化RAG检索效果。
-
-    参数：
-        text: 要分割的输入文本
-        max_length: 每个块的最大长度
-        min_length: 每个块的最小长度（除了最后一块可能较短）
-
-    返回：
-        List[str]: 文本块列表，每个块的长度尽可能接近但不超过max_length
-    """
-    if not text:
-        return []
-
-    # 如果文本长度小于最大长度，直接返回整个文本
-    if len(text) <= max_length:
-        return [text]
-
-    # 预处理：规范化文本，移除多余空白字符
-    text = ' '.join(text.split())
-
-    # 中英文标点符号集合，优化RAG召回的句子边界
-    primary_punctuation = {'.', '!', '?', '\n', '。', '！', '？'}  # 主要句末标点
-    secondary_punctuation = {'；', '：', '…', ';', ':'}  # 次级分隔符
-    tertiary_punctuation = {',', '，', '、', ')', '）', ']', '】', '}', '》', '"', "'"}  # 最低优先级
-
-    chunks = []
-    start = 0
-
-    while start < len(text):
-        # 初始化结束位置为最大可能长度
-        end = min(start + max_length, len(text))
-
-        # 只有当不是最后一块且结束位置等于最大长度时，才尝试寻找句子边界
-        if end < len(text) and end == start + max_length:
-            # 优先查找段落边界，这对RAG特别重要
-            paragraph_boundary = text.rfind('\n\n', start, end)
-            if paragraph_boundary > start and paragraph_boundary < end - min_length:  # 确保不会切得太短
-                end = paragraph_boundary + 2
-            else:
-                # 寻找句子边界，从end-1位置开始
-                found_boundary = False
-                best_boundary = -1
-
-                # 扩大搜索范围以找到更好的语义边界
-                search_range = min(120, end - start - min_length)  # 扩大搜索范围，但确保新块不小于min_length
-
-                # 先尝试找主要标点（句号等）
-                for i in range(end-1, max(start, end-search_range), -1):
-                    if text[i] in primary_punctuation:
-                        best_boundary = i
-                        found_boundary = True
-                        break
-
-                # 如果没找到主要标点，再找次要标点（分号、冒号等）
-                if not found_boundary:
-                    for i in range(end-1, max(start, end-search_range), -1):
-                        if text[i] in secondary_punctuation:
-                            best_boundary = i
-                            found_boundary = True
-                            break
-
-                # 最后考虑逗号和其他可能的边界
-                if not found_boundary:
-                    for i in range(end-1, max(start, end-search_range), -1):
-                        if text[i] in tertiary_punctuation:
-                            best_boundary = i
-                            found_boundary = True
-                            break
-
-                # 如果找到了合适的边界且不会导致太短的块，使用它
-                if found_boundary and (best_boundary - start) >= min_length:
-                    end = best_boundary + 1
-
-        # 添加当前块，并确保删除开头和结尾的空白字符
-        chunk = text[start:end].strip()
-        if chunk and len(chunk) >= min_length:  # 只添加符合最小长度的非空块
-            chunks.append(chunk)
-        elif chunk and not chunks:  # 如果是第一个块且小于最小长度，也添加它
-            chunks.append(chunk)
-        elif chunk:  # 如果块太小，尝试与前一个块合并
-            if chunks:
-                if len(chunks[-1]) + len(chunk) <= max_length * 1.1:  # 允许略微超过最大长度
-                    chunks[-1] = chunks[-1] + " " + chunk
-                else:
-                    # 如果合并会导致太长，添加这个小块（特殊情况）
-                    chunks.append(chunk)
-
-        # 计算下一块的开始位置，调整重叠窗口大小以提高RAG检索质量
-        next_start = end - int(max_length * 0.2)  # 20%的重叠窗口大小
-
-        # 确保总是有前进，避免无限循环
-        if next_start <= start:
-            next_start = start + max(1, min_length // 2)
-
-        start = next_start
-
-    # 最后检查是否有太短的块，尝试合并相邻的短块
-    if len(chunks) > 1:
-        merged_chunks = []
-        i = 0
-        while i < len(chunks):
-            current = chunks[i]
-            # 如果当前块太短且不是最后一个块，尝试与下一个合并
-            if len(current) < min_length and i < len(chunks) - 1:
-                next_chunk = chunks[i + 1]
-                if len(current) + len(next_chunk) <= max_length * 1.1:
-                    merged_chunks.append(current + " " + next_chunk)
-                    i += 2  # 跳过下一个块
-                    continue
-            merged_chunks.append(current)
-            i += 1
-        chunks = merged_chunks
-
-    return chunks
-
-
-@functools.lru_cache(maxsize=1)
-def load_tokenizer() -> AutoTokenizer:
-    """
-    加载用于文本处理的分词器，使用缓存避免重复加载。
-
-    返回：
-        AutoTokenizer: 加载的分词器
-    """
-    model_name = "gpt2"
-    cache_dir = os.path.join(get_data_dir(), "huggingface", "hub")
-
-    # 检查全局缓存
-    if model_name in _global_tokenizers:
-        return _global_tokenizers[model_name]
-
-    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
-        )
-
-    # 保存到全局缓存
-    _global_tokenizers[model_name] = tokenizer
-
-    return tokenizer # type: ignore