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

jarvis/__init__.py

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

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,217 @@ 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_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)
+        subprocess.run(["git", "pull"], cwd=central_repo_path, check=True)
+
+    # 获取中心仓库中已有的方法论
+    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)
+            subprocess.run(["git", "push"], 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 +408,24 @@ 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="分享本地方法论到中心方法论仓库"
+    ),
 ) -> None:
     """Jarvis AI assistant command-line interface."""
     if ctx.invoked_subcommand is not None:
@@ -209,7 +433,15 @@ 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)
+
+    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,11 @@
       },
       "default": []
     },
+    "JARVIS_CENTRAL_METHODOLOGY_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,

jarvis/jarvis_tools/clear_memory.py

@@ -0,0 +1,252 @@
+# -*- coding: utf-8 -*-
+import json
+import shutil
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from jarvis.jarvis_utils.config import get_data_dir
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+from jarvis.jarvis_utils.globals import (
+    clear_short_term_memories,
+    get_short_term_memories,
+    short_term_memories,
+)
+
+
+class ClearMemoryTool:
+    """清除记忆工具，用于批量清除指定的记忆"""
+
+    name = "clear_memory"
+    description = """批量清除指定的记忆。
+    
+    支持的清除方式：
+    1. 按记忆类型清除所有记忆
+    2. 按标签清除特定记忆
+    3. 按记忆ID清除单个记忆
+    
+    支持的记忆类型：
+    - project_long_term: 项目长期记忆
+    - global_long_term: 全局长期记忆
+    - short_term: 短期记忆
+    - all: 所有类型的记忆
+    
+    注意：清除操作不可恢复，请谨慎使用
+    """
+
+    parameters = {
+        "type": "object",
+        "properties": {
+            "memory_types": {
+                "type": "array",
+                "items": {
+                    "type": "string",
+                    "enum": [
+                        "project_long_term",
+                        "global_long_term",
+                        "short_term",
+                        "all",
+                    ],
+                },
+                "description": "要清除的记忆类型列表",
+            },
+            "tags": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "要清除的记忆标签列表（可选，如果指定则只清除带有这些标签的记忆）",
+            },
+            "memory_ids": {
+                "type": "array",
+                "items": {"type": "string"},
+                "description": "要清除的具体记忆ID列表（可选）",
+            },
+            "confirm": {
+                "type": "boolean",
+                "description": "确认清除操作（必须为true才会执行清除）",
+                "default": False,
+            },
+        },
+        "required": ["memory_types", "confirm"],
+    }
+
+    def __init__(self):
+        """初始化清除记忆工具"""
+        self.project_memory_dir = Path(".jarvis/memory")
+        self.global_memory_dir = Path(get_data_dir()) / "memory"
+
+    def _get_memory_dir(self, memory_type: str) -> Path:
+        """根据记忆类型获取存储目录"""
+        if memory_type == "project_long_term":
+            return self.project_memory_dir
+        elif memory_type in ["global_long_term", "short_term"]:
+            return self.global_memory_dir / memory_type
+        else:
+            raise ValueError(f"未知的记忆类型: {memory_type}")
+
+    def _clear_short_term_memories(
+        self, tags: Optional[List[str]] = None, memory_ids: Optional[List[str]] = None
+    ) -> Dict[str, int]:
+        """清除短期记忆"""
+        global short_term_memories
+
+        initial_count = len(short_term_memories)
+        removed_count = 0
+
+        if memory_ids:
+            # 按ID清除
+            new_memories = []
+            for memory in short_term_memories:
+                if memory.get("id") not in memory_ids:
+                    new_memories.append(memory)
+                else:
+                    removed_count += 1
+            short_term_memories[:] = new_memories
+        elif tags:
+            # 按标签清除
+            new_memories = []
+            for memory in short_term_memories:
+                memory_tags = memory.get("tags", [])
+                if not any(tag in memory_tags for tag in tags):
+                    new_memories.append(memory)
+                else:
+                    removed_count += 1
+            short_term_memories[:] = new_memories
+        else:
+            # 清除所有
+            clear_short_term_memories()
+            removed_count = initial_count
+
+        return {"total": initial_count, "removed": removed_count}
+
+    def _clear_long_term_memories(
+        self,
+        memory_type: str,
+        tags: Optional[List[str]] = None,
+        memory_ids: Optional[List[str]] = None,
+    ) -> Dict[str, int]:
+        """清除长期记忆"""
+        memory_dir = self._get_memory_dir(memory_type)
+
+        if not memory_dir.exists():
+            return {"total": 0, "removed": 0}
+
+        total_count = 0
+        removed_count = 0
+
+        # 获取所有记忆文件
+        memory_files = list(memory_dir.glob("*.json"))
+        total_count = len(memory_files)
+
+        for memory_file in memory_files:
+            try:
+                # 读取记忆内容
+                with open(memory_file, "r", encoding="utf-8") as f:
+                    memory_data = json.load(f)
+
+                should_remove = False
+
+                if memory_ids:
+                    # 按ID判断
+                    if memory_data.get("id") in memory_ids:
+                        should_remove = True
+                elif tags:
+                    # 按标签判断
+                    memory_tags = memory_data.get("tags", [])
+                    if any(tag in memory_tags for tag in tags):
+                        should_remove = True
+                else:
+                    # 清除所有
+                    should_remove = True
+
+                if should_remove:
+                    memory_file.unlink()
+                    removed_count += 1
+
+            except Exception as e:
+                PrettyOutput.print(
+                    f"处理记忆文件 {memory_file} 时出错: {str(e)}", OutputType.WARNING
+                )
+
+        # 如果目录为空，可以删除目录
+        if not any(memory_dir.iterdir()) and memory_dir != self.project_memory_dir:
+            memory_dir.rmdir()
+
+        return {"total": total_count, "removed": removed_count}
+
+    def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
+        """执行清除记忆操作"""
+        try:
+            memory_types = args.get("memory_types", [])
+            tags = args.get("tags", [])
+            memory_ids = args.get("memory_ids", [])
+            confirm = args.get("confirm", False)
+
+            if not confirm:
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": "必须设置 confirm=true 才能执行清除操作",
+                }
+
+            # 确定要清除的记忆类型
+            if "all" in memory_types:
+                types_to_clear = ["project_long_term", "global_long_term", "short_term"]
+            else:
+                types_to_clear = memory_types
+
+            # 统计结果
+            results = {}
+            total_removed = 0
+
+            # 清除各类型的记忆
+            for memory_type in types_to_clear:
+                if memory_type == "short_term":
+                    result = self._clear_short_term_memories(tags, memory_ids)
+                else:
+                    result = self._clear_long_term_memories(
+                        memory_type, tags, memory_ids
+                    )
+
+                results[memory_type] = result
+                total_removed += result["removed"]
+
+            # 生成结果报告
+            PrettyOutput.print(
+                f"记忆清除完成，共清除 {total_removed} 条记忆", OutputType.SUCCESS
+            )
+
+            # 详细报告
+            report = f"# 记忆清除报告\n\n"
+            report += f"**总计清除**: {total_removed} 条记忆\n\n"
+
+            if tags:
+                report += f"**使用标签过滤**: {', '.join(tags)}\n\n"
+
+            if memory_ids:
+                report += f"**指定记忆ID**: {', '.join(memory_ids)}\n\n"
+
+            report += "## 详细结果\n\n"
+
+            for memory_type, result in results.items():
+                report += f"### {memory_type}\n"
+                report += f"- 原有记忆: {result['total']} 条\n"
+                report += f"- 已清除: {result['removed']} 条\n"
+                report += f"- 剩余: {result['total'] - result['removed']} 条\n\n"
+
+            # 在终端显示摘要
+            for memory_type, result in results.items():
+                if result["removed"] > 0:
+                    PrettyOutput.print(
+                        f"{memory_type}: 清除了 {result['removed']}/{result['total']} 条记忆",
+                        OutputType.INFO,
+                    )
+
+            return {
+                "success": True,
+                "stdout": report,
+                "stderr": "",
+            }
+
+        except Exception as e:
+            error_msg = f"清除记忆失败: {str(e)}"
+            PrettyOutput.print(error_msg, OutputType.ERROR)
+            return {"success": False, "stdout": "", "stderr": error_msg}

jarvis/jarvis_tools/retrieve_memory.py

@@ -22,6 +22,7 @@ class RetrieveMemoryTool:
     - all: 从所有类型中检索
     
     可以通过标签过滤检索结果，支持多个标签（满足任一标签即可）
+    注意：标签数量建议不要超过10个，以保证检索效率
     """
 
     parameters = {
@@ -149,35 +150,40 @@ class RetrieveMemoryTool:
             # 格式化为Markdown输出
             markdown_output = f"# 记忆检索结果\n\n"
             markdown_output += f"**检索到 {len(all_memories)} 条记忆**\n\n"
-            
+
             if tags:
                 markdown_output += f"**使用标签过滤**: {', '.join(tags)}\n\n"
-            
+
             markdown_output += f"**记忆类型**: {', '.join(types_to_search)}\n\n"
-            
+
             markdown_output += "---\n\n"
-            
+
             # 输出所有记忆
             for i, memory in enumerate(all_memories):
                 markdown_output += f"## {i+1}. {memory.get('id', '未知ID')}\n\n"
                 markdown_output += f"**类型**: {memory.get('type', '未知类型')}\n\n"
                 markdown_output += f"**标签**: {', '.join(memory.get('tags', []))}\n\n"
-                markdown_output += f"**创建时间**: {memory.get('created_at', '未知时间')}\n\n"
-                
+                markdown_output += (
+                    f"**创建时间**: {memory.get('created_at', '未知时间')}\n\n"
+                )
+
                 # 内容部分
-                content = memory.get('content', '')
+                content = memory.get("content", "")
                 if content:
                     markdown_output += f"**内容**:\n\n{content}\n\n"
-                
+
                 # 如果有额外的元数据
-                metadata = {k: v for k, v in memory.items() 
-                           if k not in ['id', 'type', 'tags', 'created_at', 'content']}
+                metadata = {
+                    k: v
+                    for k, v in memory.items()
+                    if k not in ["id", "type", "tags", "created_at", "content"]
+                }
                 if metadata:
                     markdown_output += f"**其他信息**:\n"
                     for key, value in metadata.items():
                         markdown_output += f"- {key}: {value}\n"
                     markdown_output += "\n"
-                
+
                 markdown_output += "---\n\n"
 
             # 如果记忆较多，在终端显示摘要

jarvis/jarvis_tools/save_memory.py

@@ -1,5 +1,6 @@
 # -*- coding: utf-8 -*-
 import json
+import time
 from datetime import datetime
 from pathlib import Path
 from typing import Any, Dict, List
@@ -15,6 +16,8 @@ class SaveMemoryTool:
     name = "save_memory"
     description = """保存信息到长短期记忆系统。
     
+    支持批量保存多条记忆，可以同时保存不同类型的记忆。
+    
     支持的记忆类型：
     - project_long_term: 项目长期记忆（与当前项目相关的信息）
     - global_long_term: 全局长期记忆（通用的信息、用户喜好、知识、方法等）
@@ -27,19 +30,36 @@ class SaveMemoryTool:
     parameters = {
         "type": "object",
         "properties": {
-            "memory_type": {
-                "type": "string",
-                "enum": ["project_long_term", "global_long_term", "short_term"],
-                "description": "记忆类型",
-            },
-            "tags": {
+            "memories": {
                 "type": "array",
-                "items": {"type": "string"},
-                "description": "用于索引记忆的标签列表",
-            },
-            "content": {"type": "string", "description": "要保存的记忆内容"},
+                "items": {
+                    "type": "object",
+                    "properties": {
+                        "memory_type": {
+                            "type": "string",
+                            "enum": [
+                                "project_long_term",
+                                "global_long_term",
+                                "short_term",
+                            ],
+                            "description": "记忆类型",
+                        },
+                        "tags": {
+                            "type": "array",
+                            "items": {"type": "string"},
+                            "description": "用于索引记忆的标签列表",
+                        },
+                        "content": {
+                            "type": "string",
+                            "description": "要保存的记忆内容",
+                        },
+                    },
+                    "required": ["memory_type", "tags", "content"],
+                },
+                "description": "要保存的记忆列表",
+            }
         },
-        "required": ["memory_type", "tags", "content"],
+        "required": ["memories"],
     }
 
     def __init__(self):
@@ -58,81 +78,122 @@ class SaveMemoryTool:
 
     def _generate_memory_id(self) -> str:
         """生成唯一的记忆ID"""
+        # 添加微秒级时间戳确保唯一性
+        time.sleep(0.001)  # 确保不同记忆有不同的时间戳
         return datetime.now().strftime("%Y%m%d_%H%M%S_%f")
 
+    def _save_single_memory(self, memory_data: Dict[str, Any]) -> Dict[str, Any]:
+        """保存单条记忆"""
+        memory_type = memory_data["memory_type"]
+        tags = memory_data.get("tags", [])
+        content = memory_data.get("content", "")
+
+        # 生成记忆ID
+        memory_id = self._generate_memory_id()
+
+        # 创建记忆对象
+        memory_obj = {
+            "id": memory_id,
+            "type": memory_type,
+            "tags": tags,
+            "content": content,
+            "created_at": datetime.now().isoformat(),
+            "updated_at": datetime.now().isoformat(),
+        }
+
+        if memory_type == "short_term":
+            # 短期记忆保存到全局变量
+            add_short_term_memory(memory_obj)
+
+            result = {
+                "memory_id": memory_id,
+                "memory_type": memory_type,
+                "tags": tags,
+                "storage": "memory",
+                "message": f"短期记忆已成功保存到内存，ID: {memory_id}",
+            }
+        else:
+            # 长期记忆保存到文件
+            # 获取存储目录并确保存在
+            memory_dir = self._get_memory_dir(memory_type)
+            memory_dir.mkdir(parents=True, exist_ok=True)
+
+            # 保存记忆文件
+            memory_file = memory_dir / f"{memory_id}.json"
+            with open(memory_file, "w", encoding="utf-8") as f:
+                json.dump(memory_obj, f, ensure_ascii=False, indent=2)
+
+            result = {
+                "memory_id": memory_id,
+                "memory_type": memory_type,
+                "tags": tags,
+                "file_path": str(memory_file),
+                "message": f"记忆已成功保存，ID: {memory_id}",
+            }
+
+        return result
+
     def execute(self, args: Dict[str, Any]) -> Dict[str, Any]:
         """执行保存记忆操作"""
         try:
-            memory_type = args["memory_type"]
-            tags = args.get("tags", [])
-            content = args.get("content", "")
+            memories = args.get("memories", [])
 
-            # 生成记忆ID
-            memory_id = self._generate_memory_id()
+            if not memories:
+                return {
+                    "success": False,
+                    "stdout": "",
+                    "stderr": "没有提供要保存的记忆",
+                }
 
-            # 创建记忆对象
-            memory_data = {
-                "id": memory_id,
-                "type": memory_type,
-                "tags": tags,
-                "content": content,
-                "created_at": datetime.now().isoformat(),
-                "updated_at": datetime.now().isoformat(),
+            results = []
+            success_count = 0
+            failed_count = 0
+
+            # 保存每条记忆
+            for i, memory_data in enumerate(memories):
+                try:
+                    result = self._save_single_memory(memory_data)
+                    results.append(result)
+                    success_count += 1
+
+                    # 打印单条记忆保存信息
+                    memory_type = memory_data["memory_type"]
+                    tags = memory_data.get("tags", [])
+                    PrettyOutput.print(
+                        f"[{i+1}/{len(memories)}] {memory_type} 记忆已保存\n"
+                        f"ID: {result['memory_id']}\n"
+                        f"标签: {', '.join(tags)}",
+                        OutputType.SUCCESS,
+                    )
+                except Exception as e:
+                    failed_count += 1
+                    error_msg = f"保存第 {i+1} 条记忆失败: {str(e)}"
+                    PrettyOutput.print(error_msg, OutputType.ERROR)
+                    results.append(
+                        {
+                            "error": error_msg,
+                            "memory_type": memory_data.get("memory_type", "unknown"),
+                            "tags": memory_data.get("tags", []),
+                        }
+                    )
+
+            # 生成总结报告
+            PrettyOutput.print(
+                f"\n批量保存完成：成功 {success_count} 条，失败 {failed_count} 条",
+                OutputType.INFO,
+            )
+
+            # 构建返回结果
+            output = {
+                "total": len(memories),
+                "success": success_count,
+                "failed": failed_count,
+                "results": results,
             }
 
-            if memory_type == "short_term":
-                # 短期记忆保存到全局变量
-                add_short_term_memory(memory_data)
-
-                # 打印成功信息
-                PrettyOutput.print(
-                    f"短期记忆已保存\n"
-                    f"ID: {memory_id}\n"
-                    f"类型: {memory_type}\n"
-                    f"标签: {', '.join(tags)}\n"
-                    f"存储位置: 内存（非持久化）",
-                    OutputType.SUCCESS,
-                )
-
-                result = {
-                    "memory_id": memory_id,
-                    "memory_type": memory_type,
-                    "tags": tags,
-                    "storage": "memory",
-                    "message": f"短期记忆已成功保存到内存，ID: {memory_id}",
-                }
-            else:
-                # 长期记忆保存到文件
-                # 获取存储目录并确保存在
-                memory_dir = self._get_memory_dir(memory_type)
-                memory_dir.mkdir(parents=True, exist_ok=True)
-
-                # 保存记忆文件
-                memory_file = memory_dir / f"{memory_id}.json"
-                with open(memory_file, "w", encoding="utf-8") as f:
-                    json.dump(memory_data, f, ensure_ascii=False, indent=2)
-
-                # 打印成功信息
-                PrettyOutput.print(
-                    f"记忆已保存\n"
-                    f"ID: {memory_id}\n"
-                    f"类型: {memory_type}\n"
-                    f"标签: {', '.join(tags)}\n"
-                    f"位置: {memory_file}",
-                    OutputType.SUCCESS,
-                )
-
-                result = {
-                    "memory_id": memory_id,
-                    "memory_type": memory_type,
-                    "tags": tags,
-                    "file_path": str(memory_file),
-                    "message": f"记忆已成功保存，ID: {memory_id}",
-                }
-
             return {
                 "success": True,
-                "stdout": json.dumps(result, ensure_ascii=False, indent=2),
+                "stdout": json.dumps(output, ensure_ascii=False, indent=2),
                 "stderr": "",
             }
 

jarvis/jarvis_utils/config.py

@@ -309,6 +309,16 @@ def get_methodology_dirs() -> List[str]:
     return GLOBAL_CONFIG_DATA.get("JARVIS_METHODOLOGY_DIRS", [])
 
 
+def get_central_methodology_repo() -> str:
+    """
+    获取中心方法论Git仓库地址。
+
+    返回:
+        str: 中心方法论Git仓库地址，如果未配置则返回空字符串
+    """
+    return GLOBAL_CONFIG_DATA.get("JARVIS_CENTRAL_METHODOLOGY_REPO", "")
+
+
 def is_print_prompt() -> bool:
     """
     获取是否打印提示。

jarvis/jarvis_utils/input.py

@@ -216,9 +216,11 @@ def _get_multiline_input_internal(tip: str) -> str:
     @bindings.add("enter")
     def _(event):
         if event.current_buffer.complete_state:
-            event.current_buffer.apply_completion(
-                event.current_buffer.complete_state.current_completion
-            )
+            completion = event.current_buffer.complete_state.current_completion
+            if completion:
+                event.current_buffer.apply_completion(completion)
+            else:
+                event.current_buffer.insert_text("\n")
         else:
             event.current_buffer.insert_text("\n")
 

jarvis/jarvis_utils/methodology.py

@@ -15,11 +15,16 @@ from typing import Any, Dict, List, Optional
 
 from jarvis.jarvis_platform.base import BasePlatform
 from jarvis.jarvis_platform.registry import PlatformRegistry
-from jarvis.jarvis_utils.config import get_data_dir, get_methodology_dirs
+from jarvis.jarvis_utils.config import (
+    get_data_dir,
+    get_methodology_dirs,
+    get_central_methodology_repo,
+)
 from jarvis.jarvis_utils.globals import get_agent, current_agent_name
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.utils import is_context_overflow, daily_check_git_updates
 
+
 def _get_methodology_directory() -> str:
     """
     获取方法论目录路径，如果不存在则创建
@@ -46,6 +51,29 @@ def _load_all_methodologies() -> Dict[str, str]:
     all_methodologies = {}
     methodology_dirs = [_get_methodology_directory()] + get_methodology_dirs()
 
+    # 如果配置了中心方法论仓库，将其添加到加载路径
+    central_repo = get_central_methodology_repo()
+    if central_repo:
+        # 中心方法论仓库存储在数据目录下的特定位置
+        central_repo_path = os.path.join(get_data_dir(), "central_methodology_repo")
+        methodology_dirs.append(central_repo_path)
+
+        # 确保中心方法论仓库被克隆/更新
+        if not os.path.exists(central_repo_path):
+            try:
+                import subprocess
+
+                PrettyOutput.print(
+                    f"正在克隆中心方法论仓库: {central_repo}", OutputType.INFO
+                )
+                subprocess.run(
+                    ["git", "clone", central_repo, central_repo_path], check=True
+                )
+            except Exception as e:
+                PrettyOutput.print(
+                    f"克隆中心方法论仓库失败: {str(e)}", OutputType.ERROR
+                )
+
     # --- 全局每日更新检查 ---
     daily_check_git_updates(methodology_dirs, "methodologies")
 
@@ -53,7 +81,9 @@ def _load_all_methodologies() -> Dict[str, str]:
 
     for directory in set(methodology_dirs):  # Use set to avoid duplicates
         if not os.path.isdir(directory):
-            PrettyOutput.print(f"警告: 方法论目录不存在或不是一个目录: {directory}", OutputType.WARNING)
+            PrettyOutput.print(
+                f"警告: 方法论目录不存在或不是一个目录: {directory}", OutputType.WARNING
+            )
             continue
 
         for filepath in glob.glob(os.path.join(directory, "*.json")):
@@ -64,7 +94,7 @@ def _load_all_methodologies() -> Dict[str, str]:
                     content = methodology.get("content", "")
                     if problem_type and content:
                         if problem_type in all_methodologies:
-                            PrettyOutput.print(f"警告: 方法论 '{problem_type}' 被 '{filepath}' 覆盖。", OutputType.WARNING)
+                            pass
                         all_methodologies[problem_type] = content
             except Exception as e:
                 filename = os.path.basename(filepath)
@@ -211,8 +241,9 @@ def load_methodology(user_input: str, tool_registery: Optional[Any] = None) -> s
 
         # 从响应中提取<NUM>标签内的内容
         import re
-        num_match = re.search(r'<NUM>(.*?)</NUM>', response, re.DOTALL)
-        
+
+        num_match = re.search(r"<NUM>(.*?)</NUM>", response, re.DOTALL)
+
         if not num_match:
             # 如果没有找到<NUM>标签，尝试直接解析响应
             selected_indices_str = response
@@ -226,7 +257,11 @@ def load_methodology(user_input: str, tool_registery: Optional[Any] = None) -> s
         selected_methodologies = {}
         try:
             if selected_indices_str:
-                indices = [int(idx.strip()) for idx in selected_indices_str.split(",") if idx.strip().isdigit()]
+                indices = [
+                    int(idx.strip())
+                    for idx in selected_indices_str.split(",")
+                    if idx.strip().isdigit()
+                ]
                 for idx in indices:
                     if 1 <= idx <= len(methodology_titles):
                         title = methodology_titles[idx - 1]

jarvis/jarvis_utils/output.py

@@ -204,7 +204,7 @@ class PrettyOutput:
                 color="red", frame=True, bgcolor="#2b1c1c", meta={"icon": "❌"}
             ),
             OutputType.INFO: RichStyle(
-                color="gold1", frame=True, bgcolor="#2b2b1c", meta={"icon": "ℹ️"}
+                color="bright_cyan", frame=True, bgcolor="#2b2b1c", meta={"icon": "ℹ️"}
             ),
             OutputType.PLANNING: RichStyle(
                 color="purple",

{jarvis_ai_assistant-0.2.6.dist-info → jarvis_ai_assistant-0.2.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jarvis-ai-assistant
-Version: 0.2.6
+Version: 0.2.7
 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.2.6.dist-info → jarvis_ai_assistant-0.2.7.dist-info}/RECORD

@@ -1,8 +1,8 @@
-jarvis/__init__.py,sha256=LeVLn20oHpcp1TpDsXJ8P6m_z_MKXTzTQvPUv3CRNK4,73
-jarvis/jarvis_agent/__init__.py,sha256=nhJ9QOdFQJHpdLsFO0_JNH0XJHvXxMDHDTP4b7-OSnA,26370
+jarvis/__init__.py,sha256=2oEyA1qaR5QI1ZfAHJn9_9z3DRmOtWPUEtfnySBHunk,73
+jarvis/jarvis_agent/__init__.py,sha256=feyq1jxhgzAy8y0X7nNidmFTm8gkpJdhikzmphZNU7M,26945
 jarvis/jarvis_agent/builtin_input_handler.py,sha256=Qs4LAr4xdKLBJpQE81YP4CkucAop86ms0iVoKa1nnso,2468
 jarvis/jarvis_agent/edit_file_handler.py,sha256=w-byNJ4TN_SlV3djjfFC7OksySOFGrM8ku49w662dzc,11854
-jarvis/jarvis_agent/jarvis.py,sha256=L2sI-Y7gxqH6M4E4F2GlNoZcxxvz_f72rxvjh7bxuZE,8443
+jarvis/jarvis_agent/jarvis.py,sha256=Z4Alt7J5cOKUkdkPuSqPD-Zy338Zg8IizJZ3SzCRWbg,17696
 jarvis/jarvis_agent/main.py,sha256=56pLVy6v-3ZdyPCcWXdRkgbjmYsoIfC7zrA6B7sYivU,3334
 jarvis/jarvis_agent/output_handler.py,sha256=P7oWpXBGFfOsWq7cIhS_z9crkQ19ES7qU5pM92KKjAs,1172
 jarvis/jarvis_agent/prompt_builder.py,sha256=PH1fPDVa8z_RXkoXHJFNDf8PQjUoLNLYwkh2lC__p40,1705
@@ -12,7 +12,7 @@ jarvis/jarvis_agent/session_manager.py,sha256=DnvI9rWkVmkyO1XfKZyo9lTn4ajg4ccwzE
 jarvis/jarvis_agent/shell_input_handler.py,sha256=1IboqdxcJuoIqRpmDU10GugR9fWXUHyCEbVF4nIWbyo,1328
 jarvis/jarvis_agent/tool_executor.py,sha256=nIq-sPNgrtimtM-IHpN09cWmId8jDzWRdCFoRzXnnoo,1721
 jarvis/jarvis_code_agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-jarvis/jarvis_code_agent/code_agent.py,sha256=C761NUsz3W_SLJLEj6Y_HB9ox-joOlnJQ9CsfE88IFk,29100
+jarvis/jarvis_code_agent/code_agent.py,sha256=t1i9XPihW7xrsYn6I86_QvCocVgHgIg0ORQ-ADcheeM,29132
 jarvis/jarvis_code_agent/lint.py,sha256=LZPsfyZPMo7Wm7LN4osZocuNJwZx1ojacO3MlF870x8,4009
 jarvis/jarvis_code_analysis/code_review.py,sha256=TMov1pqDe1bg0vM1ndnYeW9ejHrRN_jMroo3T4L9yag,32368
 jarvis/jarvis_code_analysis/checklists/__init__.py,sha256=LIXAYa1sW3l7foP6kohLWnE98I_EQ0T7z5bYKHq6rJA,78
@@ -35,7 +35,7 @@ jarvis/jarvis_code_analysis/checklists/shell.py,sha256=aRFYhQQvTgbYd-uY5pc8UHIUA
 jarvis/jarvis_code_analysis/checklists/sql.py,sha256=vR0T6qC7b4dURjJVAd7kSVxyvZEQXPG1Jqc2sNTGp5c,2355
 jarvis/jarvis_code_analysis/checklists/swift.py,sha256=TPx4I6Gupvs6tSerRKmTSKEPQpOLEbH2Y7LXg1uBgxc,2566
 jarvis/jarvis_code_analysis/checklists/web.py,sha256=25gGD7pDadZQybNFvALYxWvK0VRjGQb1NVJQElwjyk0,3943
-jarvis/jarvis_data/config_schema.json,sha256=87zzs16tQOzbkkg1y1j1zQHYSw1Awsl8grYa02DwNs8,10116
+jarvis/jarvis_data/config_schema.json,sha256=ml7Z3dhjh227K1RsBPVTGJYSXFDG3p3OR-nTb_cxK88,10317
 jarvis/jarvis_data/tiktoken/9b5ad71b2ce5302211f9c61530b329a4922fc6a4,sha256=Ijkht27pm96ZW3_3OFE-7xAPtR0YyTWXoRO8_-hlsqc,1681126
 jarvis/jarvis_git_squash/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jarvis/jarvis_git_squash/main.py,sha256=6PECdAbTbrsJBRLK1pXBh4hdJ_LADh-XXSic1xJi97E,2255
@@ -73,11 +73,12 @@ jarvis/jarvis_smart_shell/main.py,sha256=ReCC9bWPlgl84ylI0uvdzlE3J6fS0XzFSLOpQQy
 jarvis/jarvis_stats/__init__.py,sha256=jJzgP43nxzLbNGs8Do4Jfta1PNCJMf1Oq9YTPd6EnFM,342
 jarvis/jarvis_stats/cli.py,sha256=KqLH-9Kd_YlBJSke3QXY90XnFmiH2kYkRacL8ygtSsM,12649
 jarvis/jarvis_stats/stats.py,sha256=qLyOJvWAv0fgV7oohAUSQ2W2E1Hr4wWgEQXDOiI-4Cg,17674
-jarvis/jarvis_stats/storage.py,sha256=SI6PwmXFy-Ryot-XQwZGHbTOuyKnxCwrN6hpuD_P5wg,12687
+jarvis/jarvis_stats/storage.py,sha256=0hs-TkmvWavsf6J2LLOLXyyZzVK8g77jecRnt89MzYE,12724
 jarvis/jarvis_stats/visualizer.py,sha256=ZIBmGELzs6c7qM01tQql1HF6eFKn6HDGVQfKXRUUIY0,8529
 jarvis/jarvis_tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jarvis/jarvis_tools/ask_user.py,sha256=M6DdLNryCE8y1JcdZHEifUgZkPUEPNKc-zDW5p0Mb1k,2029
 jarvis/jarvis_tools/base.py,sha256=tFVmK6ppsImW2BzHZmrNmMRiOJdW-4aZP6Me3VxdYcA,1194
+jarvis/jarvis_tools/clear_memory.py,sha256=HQMK70UJhhDgPPHozGaTpYizzQblUzYRwPbvD1z3z6o,8730
 jarvis/jarvis_tools/edit_file.py,sha256=hM345E9rxS-EkqCZpwwizL6fmPdTadtB798tEO5Ce3g,10417
 jarvis/jarvis_tools/execute_script.py,sha256=gMarE5yCCSPU6Dp6HlcL2KT-2xCzR-1p-oQNlYOJK58,6157
 jarvis/jarvis_tools/file_analyzer.py,sha256=aVe1jBSp0YmlypihxrGADJpYrU_7CxDETxGUNySuSlI,4044
@@ -86,29 +87,29 @@ jarvis/jarvis_tools/methodology.py,sha256=_K4GIDUodGEma3SvNRo7Qs5rliijgNespVLyAP
 jarvis/jarvis_tools/read_code.py,sha256=EnI-R-5HyIQYhMD391nZWXHIuHHBF-OJIRE0QpLcPX4,6417
 jarvis/jarvis_tools/read_webpage.py,sha256=NmDUboVZd4CGHBPRFK6dp3uqVhuGopW1bOi3TcaLDF4,2092
 jarvis/jarvis_tools/registry.py,sha256=8qhZgmmGIXJsYwtpsp_Ls8woT0qmBrthF8lIuQqOu7c,28614
-jarvis/jarvis_tools/retrieve_memory.py,sha256=CKmNym5FxHjgdc0my4IlsJ3TB3E2m0aCNFSRWjH6fKs,8221
+jarvis/jarvis_tools/retrieve_memory.py,sha256=zItXPSMGzaPyH-4p_CP3z24fBYFnCK3OQJctgVunZMI,8288
 jarvis/jarvis_tools/rewrite_file.py,sha256=eG_WKg6cVAXmuGwUqlWkcuyay5S8DOzEi8vZCmX3O8w,7255
-jarvis/jarvis_tools/save_memory.py,sha256=4KRJWiyeyaIfdjeCAflPrxJ5ZXA4gUL3tv9h6d6sFKc,5309
+jarvis/jarvis_tools/save_memory.py,sha256=DjeFb38OtK9Y_RpWYHz8vL72JdauXZTlc_Y0FUQBtiM,7486
 jarvis/jarvis_tools/search_web.py,sha256=zh6EYLQPIQneoz27Hheh-fifMeMNhrTVldXKMSsMz2Y,5801
 jarvis/jarvis_tools/virtual_tty.py,sha256=LTsg1PlsPvgaLShUaxpAKwTpyjXRr0l0qSREI7Q-fBc,26349
 jarvis/jarvis_tools/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jarvis/jarvis_tools/cli/main.py,sha256=GsfZJ4OS4Hvxh0H2XiLkgbzm-ajBsb4c0LyjuIAAatE,7718
 jarvis/jarvis_utils/__init__.py,sha256=67h0ldisGlh3oK4DAeNEL2Bl_VsI3tSmfclasyVlueM,850
 jarvis/jarvis_utils/builtin_replace_map.py,sha256=4BurljGuiG_I93EBs7mlFlPm9wYC_4CmdTG5tQWpF6g,1712
-jarvis/jarvis_utils/config.py,sha256=-ZgqIkzsp8VP5qsXke9XAGuwtAB9XlOAo_k4L6jhcrE,12904
+jarvis/jarvis_utils/config.py,sha256=ESvxmUxbxX8B80ft1H2qQsdyu73xAYvr3Dql7CYnzwI,13178
 jarvis/jarvis_utils/embedding.py,sha256=oEOEM2qf16DMYwPsQe6srET9BknyjOdY2ef0jsp3Or8,2714
 jarvis/jarvis_utils/file_processors.py,sha256=XiM248SHS7lLgQDCbORVFWqinbVDUawYxWDOsLXDxP8,3043
 jarvis/jarvis_utils/git_utils.py,sha256=dkC0HcUdm_rF5vXNoLByne3mGykZEviD3Lo_SYbwROU,21667
 jarvis/jarvis_utils/globals.py,sha256=lpS1lmWRnLgqOeoyhZlktdZK9SK8YMekc6XWamho0Jw,8561
 jarvis/jarvis_utils/http.py,sha256=eRhV3-GYuWmQ0ogq9di9WMlQkFcVb1zGCrySnOgT1x0,4392
-jarvis/jarvis_utils/input.py,sha256=g0Xa1TNZHxLaYduREV_Wc55iqHD6djN73YFJbR83gUg,9488
-jarvis/jarvis_utils/methodology.py,sha256=EqS9feS3HHgNcKYoGs-Dkhp4pGwylwXt96r2J61cxUo,9223
-jarvis/jarvis_utils/output.py,sha256=E_J_RYXtkOgRiDSHCRE9QPHY8WQmmhIotQtIQru8GZA,10888
+jarvis/jarvis_utils/input.py,sha256=KMAbSubWHo2z-gACf5PyQSGozJKXQby-fwcfzobJld0,9598
+jarvis/jarvis_utils/methodology.py,sha256=I8BTBijpApzUtRG20_Wu1Vuv0I0OoYOzshec6CMOPX8,10231
+jarvis/jarvis_utils/output.py,sha256=QRLlKObQKT0KuRSeZRqYb7NlTQvsd1oZXZ41WxeWEuU,10894
 jarvis/jarvis_utils/tag.py,sha256=f211opbbbTcSyzCDwuIK_oCnKhXPNK-RknYyGzY1yD0,431
 jarvis/jarvis_utils/utils.py,sha256=b7t2BsoPEU_3ZhippcQW9qwQD0PO-sGkjjtZ4DvwI2s,37056
-jarvis_ai_assistant-0.2.6.dist-info/licenses/LICENSE,sha256=AGgVgQmTqFvaztRtCAXsAMryUymB18gZif7_l2e1XOg,1063
-jarvis_ai_assistant-0.2.6.dist-info/METADATA,sha256=4XIqrWX0_tWmBC88XLFVlZGa2nzIbijiUxVW4g0y20I,16807
-jarvis_ai_assistant-0.2.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-jarvis_ai_assistant-0.2.6.dist-info/entry_points.txt,sha256=8cwi1VxZGU5UeSZMFiH-jG6NK95Asjukj5SBLBrGiGo,1257
-jarvis_ai_assistant-0.2.6.dist-info/top_level.txt,sha256=1BOxyWfzOP_ZXj8rVTDnNCJ92bBGB0rwq8N1PCpoMIs,7
-jarvis_ai_assistant-0.2.6.dist-info/RECORD,,
+jarvis_ai_assistant-0.2.7.dist-info/licenses/LICENSE,sha256=AGgVgQmTqFvaztRtCAXsAMryUymB18gZif7_l2e1XOg,1063
+jarvis_ai_assistant-0.2.7.dist-info/METADATA,sha256=NQFGWTpKdTU1HU9yjEjoFwSYz7DiAulBpVnB70WZDkg,16807
+jarvis_ai_assistant-0.2.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+jarvis_ai_assistant-0.2.7.dist-info/entry_points.txt,sha256=8cwi1VxZGU5UeSZMFiH-jG6NK95Asjukj5SBLBrGiGo,1257
+jarvis_ai_assistant-0.2.7.dist-info/top_level.txt,sha256=1BOxyWfzOP_ZXj8rVTDnNCJ92bBGB0rwq8N1PCpoMIs,7
+jarvis_ai_assistant-0.2.7.dist-info/RECORD,,