jarvis-ai-assistant 0.2.6__py3-none-any.whl → 0.2.8__py3-none-any.whl

jarvis/__init__.py

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

jarvis/jarvis_agent/__init__.py

@@ -614,8 +614,19 @@ class Agent:
         memory_tags = get_all_memory_tags()
         memory_tags_prompt = ""
         
+        # 检查是否有save_memory工具
+        tool_registry = self.get_tool_registry()
+        has_save_memory = False
+        if tool_registry:
+            tool_names = [tool.name for tool in tool_registry.tools.values()]
+            has_save_memory = "save_memory" in tool_names
+        
+        # 如果有save_memory工具，添加记录关键信息的提示
+        if has_save_memory:
+            memory_tags_prompt = "\n\n💡 提示：在分析任务之前，建议使用 save_memory 工具将关键信息记录下来，便于后续检索和复用。"
+        
         if any(tags for tags in memory_tags.values()):
-            memory_tags_prompt = "\n\n系统中存在以下记忆标签，你可以使用 retrieve_memory 工具检索相关记忆："
+            memory_tags_prompt += "\n\n系统中存在以下记忆标签，你可以使用 retrieve_memory 工具检索相关记忆："
             for memory_type, tags in memory_tags.items():
                 if tags:
                     type_name = {

jarvis/jarvis_agent/jarvis.py

@@ -4,7 +4,7 @@ import shutil
 import subprocess
 import sys
 from pathlib import Path
-from typing import Dict, Optional
+from typing import Dict, Optional, List
 
 import typer
 import yaml  # type: ignore
@@ -91,13 +91,19 @@ def _select_task(tasks: Dict[str, str]) -> str:
                 selected_task = tasks[task_names[choice - 1]]
                 PrettyOutput.print(f"将要执行任务:\n {selected_task}", OutputType.INFO)
                 # 询问是否需要补充信息
-                need_additional = user_confirm("需要为此任务添加补充信息吗？", default=False)
+                need_additional = user_confirm(
+                    "需要为此任务添加补充信息吗？", default=False
+                )
                 if need_additional:
                     additional_input = get_multiline_input("请输入补充信息：")
                     if additional_input:
-                        selected_task = f"{selected_task}\n\n补充信息:\n{additional_input}"
+                        selected_task = (
+                            f"{selected_task}\n\n补充信息:\n{additional_input}"
+                        )
                 return selected_task
-            PrettyOutput.print("无效的选择。请选择列表中的一个号码。", OutputType.WARNING)
+            PrettyOutput.print(
+                "无效的选择。请选择列表中的一个号码。", OutputType.WARNING
+            )
 
         except (KeyboardInterrupt, EOFError):
             return ""
@@ -183,6 +189,436 @@ def _get_and_run_task(agent: Agent, task_content: Optional[str] = None) -> None:
     raise typer.Exit(code=0)
 
 
+def _parse_selection(selection_str: str, max_value: int) -> List[int]:
+    """解析用户输入的选择字符串，支持逗号分隔和范围选择
+
+    例如: "1,2,3,4-9,20" -> [1, 2, 3, 4, 5, 6, 7, 8, 9, 20]
+    """
+    selected: set[int] = set()
+    parts = selection_str.split(",")
+
+    for part in parts:
+        part = part.strip()
+        if "-" in part:
+            # 处理范围选择
+            try:
+                start_str, end_str = part.split("-")
+                start_num = int(start_str.strip())
+                end_num = int(end_str.strip())
+                if 1 <= start_num <= max_value and 1 <= end_num <= max_value:
+                    selected.update(range(start_num, end_num + 1))
+            except ValueError:
+                continue
+        else:
+            # 处理单个数字
+            try:
+                num = int(part)
+                if 1 <= num <= max_value:
+                    selected.add(num)
+            except ValueError:
+                continue
+
+    return sorted(list(selected))
+
+
+def _handle_share_tool(config_file: Optional[str] = None) -> None:
+    """处理工具分享功能"""
+    from jarvis.jarvis_utils.config import (
+        get_central_tool_repo,
+        get_data_dir,
+    )
+    import glob
+    import shutil
+
+    # 获取中心工具仓库配置
+    central_repo = get_central_tool_repo()
+    if not central_repo:
+        PrettyOutput.print(
+            "错误：未配置中心工具仓库（JARVIS_CENTRAL_TOOL_REPO）",
+            OutputType.ERROR,
+        )
+        PrettyOutput.print("请在配置文件中设置中心工具仓库的Git地址", OutputType.INFO)
+        raise typer.Exit(code=1)
+
+    # 克隆或更新中心工具仓库
+    central_repo_path = os.path.join(get_data_dir(), "central_tool_repo")
+    if not os.path.exists(central_repo_path):
+        PrettyOutput.print(f"正在克隆中心工具仓库...", OutputType.INFO)
+        subprocess.run(["git", "clone", central_repo, central_repo_path], check=True)
+    else:
+        PrettyOutput.print(f"正在更新中心工具仓库...", OutputType.INFO)
+        # 检查是否是空仓库
+        try:
+            # 先尝试获取远程分支信息
+            result = subprocess.run(
+                ["git", "ls-remote", "--heads", "origin"],
+                cwd=central_repo_path,
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            # 如果有远程分支，执行pull
+            if result.stdout.strip():
+                subprocess.run(["git", "pull"], cwd=central_repo_path, check=True)
+            else:
+                PrettyOutput.print(
+                    "中心工具仓库是空的，将初始化为新仓库", OutputType.INFO
+                )
+        except subprocess.CalledProcessError:
+            # 如果命令失败，可能是网络问题或其他错误
+            PrettyOutput.print("无法连接到远程仓库，将跳过更新", OutputType.WARNING)
+
+    # 获取中心仓库中已有的工具文件名
+    existing_tools = set()
+    for filepath in glob.glob(os.path.join(central_repo_path, "*.py")):
+        existing_tools.add(os.path.basename(filepath))
+
+    # 只从数据目录的tools目录获取工具
+    local_tools_dir = os.path.join(get_data_dir(), "tools")
+    if not os.path.exists(local_tools_dir):
+        PrettyOutput.print(
+            f"本地工具目录不存在: {local_tools_dir}",
+            OutputType.WARNING,
+        )
+        raise typer.Exit(code=0)
+
+    # 收集本地工具文件（排除已存在的）
+    tool_files = []
+    for filepath in glob.glob(os.path.join(local_tools_dir, "*.py")):
+        filename = os.path.basename(filepath)
+        # 跳过__init__.py和已存在的文件
+        if filename == "__init__.py" or filename in existing_tools:
+            continue
+
+        # 尝试获取工具名称（通过简单解析）
+        tool_name = filename[:-3]  # 移除.py后缀
+        tool_files.append(
+            {
+                "path": filepath,
+                "filename": filename,
+                "tool_name": tool_name,
+            }
+        )
+
+    if not tool_files:
+        PrettyOutput.print(
+            "没有找到新的工具文件（所有工具可能已存在于中心仓库）",
+            OutputType.WARNING,
+        )
+        raise typer.Exit(code=0)
+
+    # 显示可选的工具
+    tool_list = ["\n可分享的工具（已排除中心仓库中已有的）："]
+    for i, tool in enumerate(tool_files, 1):
+        tool_list.append(f"[{i}] {tool['tool_name']} ({tool['filename']})")
+
+    # 一次性打印所有工具
+    PrettyOutput.print("\n".join(tool_list), OutputType.INFO)
+
+    # 让用户选择要分享的工具
+    while True:
+        try:
+            choice_str = prompt(
+                "\n请选择要分享的工具编号（支持格式: 1,2,3,4-9,20 或 all）："
+            ).strip()
+            if choice_str == "0":
+                raise typer.Exit(code=0)
+
+            selected_tools = []
+            if choice_str.lower() == "all":
+                selected_tools = tool_files
+            else:
+                selected_indices = _parse_selection(choice_str, len(tool_files))
+                if not selected_indices:
+                    PrettyOutput.print("无效的选择", OutputType.WARNING)
+                    continue
+                selected_tools = [tool_files[i - 1] for i in selected_indices]
+
+            # 确认操作
+            share_list = [
+                "\n将要分享以下工具到中心仓库（注意：文件将被移动而非复制）："
+            ]
+            for tool in selected_tools:
+                share_list.append(f"- {tool['tool_name']} ({tool['filename']})")
+            PrettyOutput.print("\n".join(share_list), OutputType.WARNING)
+
+            if not user_confirm("确认移动这些工具到中心仓库吗？（原文件将被删除）"):
+                continue
+
+            # 移动选中的工具到中心仓库
+            moved_list = []
+            for tool in selected_tools:
+                src_file = tool["path"]
+                dst_file = os.path.join(central_repo_path, tool["filename"])
+                shutil.move(src_file, dst_file)  # 使用move而不是copy
+                moved_list.append(f"已移动: {tool['tool_name']}")
+
+            # 一次性显示所有移动结果
+            if moved_list:
+                PrettyOutput.print("\n".join(moved_list), OutputType.SUCCESS)
+
+            # 提交并推送更改
+            PrettyOutput.print("\n正在提交更改...", OutputType.INFO)
+            subprocess.run(["git", "add", "."], cwd=central_repo_path, check=True)
+
+            commit_msg = f"Add {len(selected_tools)} tool(s) from local collection"
+            subprocess.run(
+                ["git", "commit", "-m", commit_msg], cwd=central_repo_path, check=True
+            )
+
+            PrettyOutput.print("正在推送到远程仓库...", OutputType.INFO)
+            # 检查是否需要设置上游分支（空仓库的情况）
+            try:
+                # 先尝试普通推送
+                subprocess.run(["git", "push"], cwd=central_repo_path, check=True)
+            except subprocess.CalledProcessError:
+                # 如果失败，可能是空仓库，尝试设置上游分支
+                try:
+                    subprocess.run(
+                        ["git", "push", "-u", "origin", "main"],
+                        cwd=central_repo_path,
+                        check=True,
+                    )
+                except subprocess.CalledProcessError:
+                    # 如果main分支不存在，尝试master分支
+                    subprocess.run(
+                        ["git", "push", "-u", "origin", "master"],
+                        cwd=central_repo_path,
+                        check=True,
+                    )
+
+            PrettyOutput.print("\n工具已成功分享到中心仓库！", OutputType.SUCCESS)
+            PrettyOutput.print(
+                f"原文件已从 {local_tools_dir} 移动到中心仓库", OutputType.INFO
+            )
+            break
+
+        except ValueError:
+            PrettyOutput.print("请输入有效的数字", OutputType.WARNING)
+        except subprocess.CalledProcessError as e:
+            PrettyOutput.print(f"Git操作失败: {str(e)}", OutputType.ERROR)
+            raise typer.Exit(code=1)
+        except Exception as e:
+            PrettyOutput.print(f"分享工具时出错: {str(e)}", OutputType.ERROR)
+            raise typer.Exit(code=1)
+
+
+def _handle_share_methodology(config_file: Optional[str] = None) -> None:
+    """处理方法论分享功能"""
+    from jarvis.jarvis_utils.config import (
+        get_central_methodology_repo,
+        get_methodology_dirs,
+        get_data_dir,
+    )
+    import glob
+    import json
+    import shutil
+
+    # 获取中心方法论仓库配置
+    central_repo = get_central_methodology_repo()
+    if not central_repo:
+        PrettyOutput.print(
+            "错误：未配置中心方法论仓库（JARVIS_CENTRAL_METHODOLOGY_REPO）",
+            OutputType.ERROR,
+        )
+        PrettyOutput.print("请在配置文件中设置中心方法论仓库的Git地址", OutputType.INFO)
+        raise typer.Exit(code=1)
+
+    # 克隆或更新中心方法论仓库
+    central_repo_path = os.path.join(get_data_dir(), "central_methodology_repo")
+    if not os.path.exists(central_repo_path):
+        PrettyOutput.print(f"正在克隆中心方法论仓库...", OutputType.INFO)
+        subprocess.run(["git", "clone", central_repo, central_repo_path], check=True)
+    else:
+        PrettyOutput.print(f"正在更新中心方法论仓库...", OutputType.INFO)
+        # 检查是否是空仓库
+        try:
+            # 先尝试获取远程分支信息
+            result = subprocess.run(
+                ["git", "ls-remote", "--heads", "origin"],
+                cwd=central_repo_path,
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            # 如果有远程分支，执行pull
+            if result.stdout.strip():
+                subprocess.run(["git", "pull"], cwd=central_repo_path, check=True)
+            else:
+                PrettyOutput.print(
+                    "中心方法论仓库是空的，将初始化为新仓库", OutputType.INFO
+                )
+        except subprocess.CalledProcessError:
+            # 如果命令失败，可能是网络问题或其他错误
+            PrettyOutput.print("无法连接到远程仓库，将跳过更新", OutputType.WARNING)
+
+    # 获取中心仓库中已有的方法论
+    existing_methodologies = {}  # 改为字典，存储 problem_type -> content 的映射
+    for filepath in glob.glob(os.path.join(central_repo_path, "*.json")):
+        try:
+            with open(filepath, "r", encoding="utf-8", errors="ignore") as f:
+                methodology = json.load(f)
+                problem_type = methodology.get("problem_type", "")
+                content = methodology.get("content", "")
+                if problem_type and content:
+                    existing_methodologies[problem_type] = content
+        except Exception:
+            pass
+
+    # 获取所有方法论目录
+    from jarvis.jarvis_utils.methodology import _get_methodology_directory
+
+    methodology_dirs = [_get_methodology_directory()] + get_methodology_dirs()
+
+    # 收集所有方法论文件（排除中心仓库目录和已存在的方法论）
+    all_methodologies = {}
+    methodology_files = []
+    seen_problem_types = set()  # 用于去重
+
+    for directory in set(methodology_dirs):
+        # 跳过中心仓库目录
+        if os.path.abspath(directory) == os.path.abspath(central_repo_path):
+            continue
+
+        if not os.path.isdir(directory):
+            continue
+
+        for filepath in glob.glob(os.path.join(directory, "*.json")):
+            try:
+                with open(filepath, "r", encoding="utf-8", errors="ignore") as f:
+                    methodology = json.load(f)
+                    problem_type = methodology.get("problem_type", "")
+                    content = methodology.get("content", "")
+                    # 基于内容判断是否已存在于中心仓库
+                    is_duplicate = False
+                    if problem_type in existing_methodologies:
+                        # 如果problem_type相同，比较内容
+                        if (
+                            content.strip()
+                            == existing_methodologies[problem_type].strip()
+                        ):
+                            is_duplicate = True
+
+                    # 排除已存在于中心仓库的方法论（基于内容），以及本地重复的方法论
+                    if (
+                        problem_type
+                        and content
+                        and not is_duplicate
+                        and problem_type not in seen_problem_types
+                    ):
+                        methodology_files.append(
+                            {
+                                "path": filepath,
+                                "problem_type": problem_type,
+                                "directory": directory,
+                            }
+                        )
+                        all_methodologies[problem_type] = methodology
+                        seen_problem_types.add(problem_type)
+            except Exception:
+                pass
+
+    if not methodology_files:
+        PrettyOutput.print(
+            "没有找到新的方法论文件（所有方法论可能已存在于中心仓库）",
+            OutputType.WARNING,
+        )
+        raise typer.Exit(code=0)
+
+    # 显示可选的方法论
+    methodology_list = ["\n可分享的方法论（已排除中心仓库中已有的）："]
+    for i, meth in enumerate(methodology_files, 1):
+        dir_name = os.path.basename(meth["directory"])
+        methodology_list.append(f"[{i}] {meth['problem_type']} (来自: {dir_name})")
+
+    # 一次性打印所有方法论
+    PrettyOutput.print("\n".join(methodology_list), OutputType.INFO)
+
+    # 让用户选择要分享的方法论
+    while True:
+        try:
+            choice_str = prompt(
+                "\n请选择要分享的方法论编号（支持格式: 1,2,3,4-9,20 或 all）："
+            ).strip()
+            if choice_str == "0":
+                raise typer.Exit(code=0)
+
+            selected_methodologies = []
+            if choice_str.lower() == "all":
+                selected_methodologies = methodology_files
+            else:
+                selected_indices = _parse_selection(choice_str, len(methodology_files))
+                if not selected_indices:
+                    PrettyOutput.print("无效的选择", OutputType.WARNING)
+                    continue
+                selected_methodologies = [
+                    methodology_files[i - 1] for i in selected_indices
+                ]
+
+            # 确认操作
+            share_list = ["\n将要分享以下方法论到中心仓库："]
+            for meth in selected_methodologies:
+                share_list.append(f"- {meth['problem_type']}")
+            PrettyOutput.print("\n".join(share_list), OutputType.INFO)
+
+            if not user_confirm("确认分享这些方法论吗？"):
+                continue
+
+            # 复制选中的方法论到中心仓库
+            copied_list = []
+            for meth in selected_methodologies:
+                src_file = meth["path"]
+                dst_file = os.path.join(central_repo_path, os.path.basename(src_file))
+                shutil.copy2(src_file, dst_file)
+                copied_list.append(f"已复制: {meth['problem_type']}")
+
+            # 一次性显示所有复制结果
+            if copied_list:
+                PrettyOutput.print("\n".join(copied_list), OutputType.SUCCESS)
+
+            # 提交并推送更改
+            PrettyOutput.print("\n正在提交更改...", OutputType.INFO)
+            subprocess.run(["git", "add", "."], cwd=central_repo_path, check=True)
+
+            commit_msg = f"Add {len(selected_methodologies)} methodology(ies) from local collection"
+            subprocess.run(
+                ["git", "commit", "-m", commit_msg], cwd=central_repo_path, check=True
+            )
+
+            PrettyOutput.print("正在推送到远程仓库...", OutputType.INFO)
+            # 检查是否需要设置上游分支（空仓库的情况）
+            try:
+                # 先尝试普通推送
+                subprocess.run(["git", "push"], cwd=central_repo_path, check=True)
+            except subprocess.CalledProcessError:
+                # 如果失败，可能是空仓库，尝试设置上游分支
+                try:
+                    subprocess.run(
+                        ["git", "push", "-u", "origin", "main"],
+                        cwd=central_repo_path,
+                        check=True,
+                    )
+                except subprocess.CalledProcessError:
+                    # 如果main分支不存在，尝试master分支
+                    subprocess.run(
+                        ["git", "push", "-u", "origin", "master"],
+                        cwd=central_repo_path,
+                        check=True,
+                    )
+
+            PrettyOutput.print("\n方法论已成功分享到中心仓库！", OutputType.SUCCESS)
+            break
+
+        except ValueError:
+            PrettyOutput.print("请输入有效的数字", OutputType.WARNING)
+        except subprocess.CalledProcessError as e:
+            PrettyOutput.print(f"Git操作失败: {str(e)}", OutputType.ERROR)
+            raise typer.Exit(code=1)
+        except Exception as e:
+            PrettyOutput.print(f"分享方法论时出错: {str(e)}", OutputType.ERROR)
+            raise typer.Exit(code=1)
+
+
 @app.callback(invoke_without_command=True)
 def run_cli(
     ctx: typer.Context,
@@ -191,17 +627,27 @@ def run_cli(
         "--llm_type",
         help="使用的LLM类型，可选值：'normal'（普通）或 'thinking'（思考模式）",
     ),
-    task: Optional[str] = typer.Option(None, "-t", "--task", help="从命令行直接输入任务内容"),
+    task: Optional[str] = typer.Option(
+        None, "-t", "--task", help="从命令行直接输入任务内容"
+    ),
     model_group: Optional[str] = typer.Option(
         None, "--llm_group", help="使用的模型组，覆盖配置文件中的设置"
     ),
-    config_file: Optional[str] = typer.Option(None, "-f", "--config", help="自定义配置文件路径"),
+    config_file: Optional[str] = typer.Option(
+        None, "-f", "--config", help="自定义配置文件路径"
+    ),
     restore_session: bool = typer.Option(
         False,
         "--restore-session",
         help="从 .jarvis/saved_session.json 恢复会话",
     ),
     edit: bool = typer.Option(False, "-e", "--edit", help="编辑配置文件"),
+    share_methodology: bool = typer.Option(
+        False, "--share-methodology", help="分享本地方法论到中心方法论仓库"
+    ),
+    share_tool: bool = typer.Option(
+        False, "--share-tool", help="分享本地工具到中心工具仓库"
+    ),
 ) -> None:
     """Jarvis AI assistant command-line interface."""
     if ctx.invoked_subcommand is not None:
@@ -209,7 +655,21 @@ def run_cli(
 
     _handle_edit_mode(edit, config_file)
 
-    init_env("欢迎使用 Jarvis AI 助手，您的智能助理已准备就绪！", config_file=config_file)
+    # 处理方法论分享
+    if share_methodology:
+        init_env("", config_file=config_file)  # 初始化配置但不显示欢迎信息
+        _handle_share_methodology(config_file)
+        raise typer.Exit(code=0)
+
+    # 处理工具分享
+    if share_tool:
+        init_env("", config_file=config_file)  # 初始化配置但不显示欢迎信息
+        _handle_share_tool(config_file)
+        raise typer.Exit(code=0)
+
+    init_env(
+        "欢迎使用 Jarvis AI 助手，您的智能助理已准备就绪！", config_file=config_file
+    )
 
     try:
         agent = _initialize_agent(llm_type, model_group, restore_session)

jarvis/jarvis_code_agent/code_agent.py

@@ -67,6 +67,7 @@ class CodeAgent:
                 "rewrite_file",
                 "save_memory",
                 "retrieve_memory",
+                "clear_memory",
             ]
         )
         code_system_prompt = """

jarvis/jarvis_data/config_schema.json

@@ -225,6 +225,16 @@
       },
       "default": []
     },
+    "JARVIS_CENTRAL_METHODOLOGY_REPO": {
+      "type": "string",
+      "description": "中心方法论Git仓库地址，该仓库会自动添加到方法论加载路径中",
+      "default": ""
+    },
+    "JARVIS_CENTRAL_TOOL_REPO": {
+      "type": "string",
+      "description": "中心工具库Git仓库地址，该仓库会自动克隆到数据目录并加载其中的工具",
+      "default": ""
+    },
     "JARVIS_PRINT_PROMPT": {
       "type": "boolean",
       "description": "是否打印提示",

jarvis/jarvis_stats/storage.py

@@ -245,7 +245,7 @@ class StatsStorage:
         metrics_from_meta = set(meta.get("metrics", {}).keys())
         
         # 扫描所有数据文件获取实际存在的指标
-        metrics_from_data = set()
+        metrics_from_data: set[str] = set()
         for data_file in self.data_dir.glob("stats_*.json"):
             try:
                 data = self._load_json(data_file)
@@ -285,7 +285,7 @@ class StatsStorage:
             return {}
 
         # 聚合数据
-        aggregated = defaultdict(
+        aggregated: Dict[str, Dict[str, Any]] = defaultdict(
             lambda: {
                 "count": 0,
                 "sum": 0,