jarvis-ai-assistant 0.3.1__py3-none-any.whl → 0.3.3__py3-none-any.whl

jarvis/jarvis_platform/base.py

@@ -255,6 +255,15 @@ class BasePlatform(ABC):
         """Get env default values"""
         return {}
 
+    @classmethod
+    def get_env_config_guide(cls) -> Dict[str, str]:
+        """Get environment variable configuration guide
+
+        Returns:
+            Dict[str, str]: A dictionary mapping env key names to their configuration instructions
+        """
+        return {}
+
     def set_suppress_output(self, suppress: bool):
         """Set whether to suppress output"""
         self.suppress_output = suppress

jarvis/jarvis_platform/kimi.py

@@ -405,3 +405,23 @@ class KimiModel(BasePlatform):
             List[str]: 环境变量键的列表
         """
         return ["KIMI_API_KEY"]
+
+    @classmethod
+    def get_env_config_guide(cls) -> Dict[str, str]:
+        """
+        获取环境变量配置指导
+
+        返回:
+            Dict[str, str]: 环境变量名到配置指导的映射
+        """
+        return {
+            "KIMI_API_KEY": (
+                "1. 登录 Kimi 网页版: https://kimi.moonshot.cn/\n"
+                "2. 打开浏览器开发者工具 (F12)\n"
+                '3. 切换到"网络"(Network)标签页\n'
+                "4. 在 Kimi 中发送一条消息\n"
+                "5. 找到 stream 请求\n"
+                '6. 在"请求标头"中找到 authorization 字段\n'
+                "7. 复制 Bearer 后面的 API Key 部分"
+            )
+        }

jarvis/jarvis_platform/openai.py

@@ -222,6 +222,33 @@ class OpenAIModel(BasePlatform):
         """
         return ["OPENAI_API_KEY", "OPENAI_API_BASE"]
 
+    @classmethod
+    def get_env_config_guide(cls) -> Dict[str, str]:
+        """
+        获取环境变量配置指导
+
+        返回:
+            Dict[str, str]: 环境变量名到配置指导的映射
+        """
+        return {
+            "OPENAI_API_KEY": (
+                "请输入您的 OpenAI API Key:\n"
+                "获取方式一（官方）:\n"
+                "1. 登录 OpenAI 平台: https://platform.openai.com/\n"
+                "2. 进入 API Keys 页面\n"
+                "3. 创建新的 API Key 或使用现有的\n"
+                "4. 复制 API Key (以 sk- 开头)\n"
+                "\n获取方式二（第三方代理）:\n"
+                "如果使用第三方代理服务，请从代理服务商处获取 API Key"
+            ),
+            "OPENAI_API_BASE": (
+                "请输入 API Base URL:\n"
+                "- 官方 API: https://api.openai.com/v1\n"
+                "- 如使用代理或第三方服务，请输入对应的 Base URL\n"
+                "- 例如: https://your-proxy.com/v1"
+            ),
+        }
+
     @classmethod
     def get_env_defaults(cls) -> Dict[str, str]:
         """

jarvis/jarvis_platform/tongyi.py

@@ -567,3 +567,22 @@ class TongyiPlatform(BasePlatform):
             List[str]: 环境变量键的列表
         """
         return ["TONGYI_COOKIES"]
+
+    @classmethod
+    def get_env_config_guide(cls) -> Dict[str, str]:
+        """
+        获取环境变量配置指导
+
+        返回:
+            Dict[str, str]: 环境变量名到配置指导的映射
+        """
+        return {
+            "TONGYI_COOKIES": (
+                "1. 登录通义千问网页版: https://tongyi.aliyun.com/\n"
+                "2. 打开浏览器开发者工具 (F12)\n"
+                '3. 切换到"网络"(Network)标签页\n'
+                "4. 刷新页面或发送一条消息\n"
+                "5. 找到 conversation 请求或任意发往 api.tongyi.com 的请求\n"
+                '6. 在"请求标头"中复制完整的 Cookie 值'
+            )
+        }

jarvis/jarvis_platform/yuanbao.py

@@ -633,3 +633,21 @@ class YuanbaoPlatform(BasePlatform):
             List[str]: 环境变量键的列表
         """
         return ["YUANBAO_COOKIES"]
+
+    @classmethod
+    def get_env_config_guide(cls) -> Dict[str, str]:
+        """
+        获取环境变量配置指导
+
+        返回:
+            Dict[str, str]: 环境变量名到配置指导的映射
+        """
+        return {
+            "YUANBAO_COOKIES": (
+                "1. 登录腾讯元宝网页版: https://yuanbao.tencent.com/\n"
+                "2. 打开浏览器开发者工具 (F12)\n"
+                '3. 切换到"网络"(Network)标签页\n'
+                "4. 刷新页面，找到任意一个发往 yuanbao.tencent.com 的请求\n"
+                '5. 在"请求标头"中复制完整的 Cookie 值'
+            )
+        }

jarvis/jarvis_platform_manager/main.py

@@ -8,6 +8,12 @@ import sys
 from typing import Any, Dict, List, Optional
 
 import typer
+from jarvis.jarvis_utils.config import (
+    get_normal_platform_name,
+    get_normal_model_name,
+    get_thinking_platform_name,
+    get_thinking_model_name,
+)
 
 from jarvis.jarvis_platform.registry import PlatformRegistry
 from jarvis.jarvis_utils.input import get_multiline_input, get_single_line_input
@@ -19,22 +25,26 @@ app = typer.Typer(help="Jarvis AI 平台")
 
 
 @app.command("info")
-def list_platforms() -> None:
-    """列出所有支持的平台和模型。"""
+def list_platforms(
+    platform: Optional[str] = typer.Option(
+        None, "--platform", "-p", help="指定要查看的平台"
+    )
+) -> None:
+    """列出所有支持的平台和模型，或指定平台的详细信息。"""
     registry = PlatformRegistry.get_global_platform_registry()
-    platforms = registry.get_available_platforms()
+    platform_names = [platform] if platform else registry.get_available_platforms()
 
     PrettyOutput.section("Supported platforms and models", OutputType.SUCCESS)
 
-    for platform_name in platforms:
+    for platform_name in platform_names:
         try:
             # Create platform instance
-            platform = registry.create_platform(platform_name)
-            if not platform:
+            platform_instance = registry.create_platform(platform_name)
+            if not platform_instance:
                 continue
 
             # Get the list of models supported by the platform
-            models = platform.get_model_list()
+            models = platform_instance.get_model_list()
 
             # Print platform name
             PrettyOutput.section(f"{platform_name}", OutputType.SUCCESS)
@@ -55,13 +65,25 @@ def list_platforms() -> None:
             PrettyOutput.print(f"创建 {platform_name} 平台失败", OutputType.WARNING)
 
 
-def chat_with_model(platform_name: str, model_name: str, system_prompt: str) -> None:
-    """与指定平台和模型进行对话。"""
+def chat_with_model(
+    platform_name: str, model_name: str, system_prompt: str, llm_type: str = "normal"
+) -> None:
+    """与指定平台和模型进行对话。
+
+    参数:
+        platform_name: 平台名称
+        model_name: 模型名称
+        system_prompt: 系统提示语
+        llm_type: LLM类型，可选值：'normal'(普通)或 'thinking'(思考模式)
+    """
     registry = PlatformRegistry.get_global_platform_registry()
     conversation_history: List[Dict[str, str]] = []  # 存储对话记录
 
     # Create platform instance
     platform = registry.create_platform(platform_name)
+    if platform:
+        platform.set_model_name(model_name)
+
     if not platform:
         PrettyOutput.print(f"创建平台 {platform_name} 失败", OutputType.WARNING)
         return
@@ -97,10 +119,16 @@ def chat_with_model(platform_name: str, model_name: str, system_prompt: str) ->
                 PrettyOutput.print("检测到空输入，退出聊天", OutputType.INFO)
                 break
 
+            # Parse command and arguments
+            stripped_input = user_input.strip()
+            parts = stripped_input.split(None, 1)
+            command = parts[0] if parts else ""
+            args = parts[1] if len(parts) > 1 else ""
+
             # Check if it is a clear session command
-            if user_input.strip() == "/clear":
+            if command == "/clear":
                 try:
-                    platform.reset()
+                    platform.reset()  # type: ignore[no-untyped-call]  # type: ignore[no-untyped-call]  # type: ignore[no-untyped-call]
                     platform.set_model_name(model_name)  # Reinitialize session
                     conversation_history = []  # 重置对话记录
                     PrettyOutput.print("会话已清除", OutputType.SUCCESS)
@@ -109,9 +137,9 @@ def chat_with_model(platform_name: str, model_name: str, system_prompt: str) ->
                 continue
 
             # Check if it is an upload command
-            if user_input.strip().startswith("/upload"):
+            if command == "/upload":
                 try:
-                    file_path = user_input.strip()[8:].strip()
+                    file_path = args
                     if not file_path:
                         PrettyOutput.print(
                             '请指定要上传的文件路径，例如: /upload /path/to/file 或 /upload "/path/with spaces/file"',
@@ -139,9 +167,9 @@ def chat_with_model(platform_name: str, model_name: str, system_prompt: str) ->
                 continue
 
             # Check if it is a save command
-            if user_input.strip().startswith("/save"):
+            if command == "/save":
                 try:
-                    file_path = user_input.strip()[5:].strip()
+                    file_path = args
                     if not file_path:
                         PrettyOutput.print(
                             "请指定保存文件名，例如: /save last_message.txt",
@@ -170,9 +198,9 @@ def chat_with_model(platform_name: str, model_name: str, system_prompt: str) ->
                 continue
 
             # Check if it is a saveall command
-            if user_input.strip().startswith("/saveall"):
+            if command == "/saveall":
                 try:
-                    file_path = user_input.strip()[8:].strip()
+                    file_path = args
                     if not file_path:
                         PrettyOutput.print(
                             "请指定保存文件名，例如: /saveall all_conversations.txt",
@@ -201,9 +229,9 @@ def chat_with_model(platform_name: str, model_name: str, system_prompt: str) ->
                 continue
 
             # Check if it is a save_session command
-            if user_input.strip().startswith("/save_session"):
+            if command == "/save_session":
                 try:
-                    file_path = user_input.strip()[14:].strip()
+                    file_path = args
                     if not file_path:
                         PrettyOutput.print(
                             "请指定保存会话的文件名，例如: /save_session session.json",
@@ -228,9 +256,9 @@ def chat_with_model(platform_name: str, model_name: str, system_prompt: str) ->
                 continue
 
             # Check if it is a load_session command
-            if user_input.strip().startswith("/load_session"):
+            if command == "/load_session":
                 try:
-                    file_path = user_input.strip()[14:].strip()
+                    file_path = args
                     if not file_path:
                         PrettyOutput.print(
                             "请指定加载会话的文件名，例如: /load_session session.json",
@@ -256,18 +284,18 @@ def chat_with_model(platform_name: str, model_name: str, system_prompt: str) ->
                 continue
 
             # Check if it is a shell command
-            if user_input.strip().startswith("/shell"):
+            if command == "/shell":
                 try:
-                    command = user_input.strip()[6:].strip()
-                    if not command:
+                    shell_command = args
+                    if not shell_command:
                         PrettyOutput.print(
                             "请指定要执行的shell命令，例如: /shell ls -l",
                             OutputType.WARNING,
                         )
                         continue
 
-                    PrettyOutput.print(f"执行命令: {command}", OutputType.INFO)
-                    return_code = os.system(command)
+                    PrettyOutput.print(f"执行命令: {shell_command}", OutputType.INFO)
+                    return_code = os.system(shell_command)
                     if return_code == 0:
                         PrettyOutput.print("命令执行完成", OutputType.SUCCESS)
                     else:
@@ -332,11 +360,32 @@ def chat_command(
         None, "--platform", "-p", help="指定要使用的平台"
     ),
     model: Optional[str] = typer.Option(None, "--model", "-m", help="指定要使用的模型"),
+    llm_type: str = typer.Option(
+        "normal",
+        "-t",
+        "--llm_type",
+        help="使用的LLM类型，可选值：'normal'（普通）或 'thinking'（思考模式）",
+    ),
+    llm_group: Optional[str] = typer.Option(
+        None, "-g", "--llm_group", help="使用的模型组，覆盖配置文件中的设置"
+    ),
 ) -> None:
     """与指定平台和模型聊天。"""
+    # 如果未提供平台或模型参数，则从config获取默认值
+    platform = platform or (
+        get_thinking_platform_name(llm_group)
+        if llm_type == "thinking"
+        else get_normal_platform_name(llm_group)
+    )
+    model = model or (
+        get_thinking_model_name(llm_group)
+        if llm_type == "thinking"
+        else get_normal_model_name(llm_group)
+    )
+
     if not validate_platform_model(platform, model):
         return
-    chat_with_model(platform, model, "")  # type: ignore
+    chat_with_model(platform, model, "", llm_type)
 
 
 @app.command("service")
@@ -351,6 +400,9 @@ def service_command(
     ),
 ) -> None:
     """启动OpenAI兼容的API服务。"""
+    # 如果未提供平台或模型参数，则从config获取默认值
+    platform = platform or get_normal_platform_name()
+    model = model or get_normal_model_name()
     start_service(host=host, port=port, default_platform=platform, default_model=model)
 
 
@@ -392,6 +444,15 @@ def role_command(
     model: Optional[str] = typer.Option(
         None, "--model", "-m", help="指定要使用的模型，覆盖角色配置"
     ),
+    llm_type: Optional[str] = typer.Option(
+        None,
+        "-t",
+        "--llm_type",
+        help="使用的LLM类型，可选值：'normal'（普通）或 'thinking'（思考模式），覆盖角色配置",
+    ),
+    llm_group: Optional[str] = typer.Option(
+        None, "-g", "--llm_group", help="使用的模型组，覆盖配置文件中的设置"
+    ),
 ) -> None:
     """加载角色配置文件并开始对话。"""
     config_path = os.path.expanduser(config_file)
@@ -418,14 +479,54 @@ def role_command(
         PrettyOutput.print("无效的选择", OutputType.ERROR)
         return
 
+    # 获取llm_type，优先使用命令行参数，否则使用角色配置，默认为normal
+    role_llm_type = llm_type or selected_role.get("llm_type", "normal")
+
     # 初始化平台和模型
-    platform_name = platform or selected_role["platform"]
-    model_name = model or selected_role["model"]
+    # 如果提供了platform或model参数，优先使用命令行参数
+    # 否则，如果提供了llm_group，根据llm_type从配置中获取
+    # 最后才使用角色配置中的platform和model
+    if platform:
+        platform_name = platform
+    elif llm_group:
+        platform_name = (
+            get_thinking_platform_name(llm_group)
+            if role_llm_type == "thinking"
+            else get_normal_platform_name(llm_group)
+        )
+    else:
+        platform_name = selected_role.get("platform")
+        if not platform_name:
+            # 如果角色配置中没有platform，使用默认配置
+            platform_name = (
+                get_thinking_platform_name()
+                if role_llm_type == "thinking"
+                else get_normal_platform_name()
+            )
+
+    if model:
+        model_name = model
+    elif llm_group:
+        model_name = (
+            get_thinking_model_name(llm_group)
+            if role_llm_type == "thinking"
+            else get_normal_model_name(llm_group)
+        )
+    else:
+        model_name = selected_role.get("model")
+        if not model_name:
+            # 如果角色配置中没有model，使用默认配置
+            model_name = (
+                get_thinking_model_name()
+                if role_llm_type == "thinking"
+                else get_normal_model_name()
+            )
+
     system_prompt = selected_role.get("system_prompt", "")
 
     # 开始对话
     PrettyOutput.print(f"已选择角色: {selected_role['name']}", OutputType.SUCCESS)
-    chat_with_model(platform_name, model_name, system_prompt)
+    chat_with_model(platform_name, model_name, system_prompt, role_llm_type)
 
 
 def main() -> None:

jarvis/jarvis_stats/storage.py

@@ -12,6 +12,7 @@ from typing import Dict, List, Optional, Any
 from collections import defaultdict
 import sys
 import time
+import uuid
 
 
 class StatsStorage:
@@ -76,7 +77,9 @@ class StatsStorage:
     def _save_json(self, filepath: Path, data: Dict):
         """保存JSON文件"""
         # 使用临时文件+重命名的原子操作来避免并发写入问题
-        temp_filepath = filepath.with_suffix(".tmp")
+        # 使用唯一的临时文件名避免并发冲突
+        temp_suffix = f".tmp.{uuid.uuid4().hex[:8]}"
+        temp_filepath = filepath.with_suffix(temp_suffix)
         max_retries = 3
 
         for attempt in range(max_retries):

jarvis/jarvis_utils/globals.py

@@ -236,20 +236,26 @@ def get_short_term_memories(tags: Optional[List[str]] = None) -> List[Dict[str,
         tags: 用于过滤的标签列表（可选）
 
     返回:
-        List[Dict[str, Any]]: 符合条件的短期记忆列表
+        List[Dict[str, Any]]: 符合条件的短期记忆列表，按创建时间降序排列
     """
     global short_term_memories
-    if not tags:
-        return short_term_memories.copy()
 
-    # 按标签过滤
-    filtered_memories = []
-    for memory in short_term_memories:
-        memory_tags = memory.get("tags", [])
-        if any(tag in memory_tags for tag in tags):
-            filtered_memories.append(memory)
+    # 获取记忆副本
+    memories_copy = short_term_memories.copy()
+
+    # 按标签过滤（如果提供了标签）
+    if tags:
+        filtered_memories = []
+        for memory in memories_copy:
+            memory_tags = memory.get("tags", [])
+            if any(tag in memory_tags for tag in tags):
+                filtered_memories.append(memory)
+        memories_copy = filtered_memories
+
+    # 按创建时间排序（最新的在前）
+    memories_copy.sort(key=lambda x: x.get("created_at", ""), reverse=True)
 
-    return filtered_memories
+    return memories_copy
 
 
 def clear_short_term_memories() -> None:

jarvis/jarvis_utils/utils.py

@@ -26,6 +26,7 @@ from jarvis.jarvis_utils.config import (
 )
 from jarvis.jarvis_utils.embedding import get_context_token_count
 from jarvis.jarvis_utils.globals import get_in_chat, get_interrupt, set_interrupt
+from jarvis.jarvis_utils.input import user_confirm
 from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 
 g_config_file = None
@@ -57,6 +58,8 @@ COMMAND_MAPPING = {
     "jrg": "jarvis-rag",
     # 统计
     "jst": "jarvis-stats",
+    # 记忆整理
+    "jmo": "jarvis-memory-organizer",
 }
 
 
@@ -189,20 +192,12 @@ def _show_usage_stats() -> None:
 
         # 计算采纳率并添加到统计中
         commit_stats = categorized_stats["commit"]["metrics"]
-        # 尝试多种可能的指标名称
-        generated_commits = commit_stats.get(
-            "commits_generated", commit_stats.get("commit_generated", 0)
-        )
-        accepted_commits = commit_stats.get(
-            "commits_accepted",
-            commit_stats.get("commit_accepted", commit_stats.get("commit_adopted", 0)),
-        )
-        rejected_commits = commit_stats.get(
-            "commits_rejected", commit_stats.get("commit_rejected", 0)
-        )
+        # 使用精确的指标名称
+        generated_commits = commit_stats.get("commits_generated", 0)
+        accepted_commits = commit_stats.get("commits_accepted", 0)
 
-        # 如果有 generated 和 accepted，则使用这两个计算采纳率
-        if generated_commits > 0 and accepted_commits > 0:
+        # 如果有 generated，则计算采纳率
+        if generated_commits > 0:
             adoption_rate = (accepted_commits / generated_commits) * 100
             categorized_stats["adoption"]["metrics"][
                 "adoption_rate"
@@ -210,17 +205,6 @@ def _show_usage_stats() -> None:
             categorized_stats["adoption"]["metrics"][
                 "commits_status"
             ] = f"{accepted_commits}/{generated_commits}"
-        elif accepted_commits > 0 or rejected_commits > 0:
-            # 否则使用 accepted 和 rejected 计算
-            total_commits = accepted_commits + rejected_commits
-            if total_commits > 0:
-                adoption_rate = (accepted_commits / total_commits) * 100
-                categorized_stats["adoption"]["metrics"][
-                    "adoption_rate"
-                ] = f"{adoption_rate:.1f}%"
-                categorized_stats["adoption"]["metrics"][
-                    "commits_status"
-                ] = f"{accepted_commits}/{total_commits}"
 
         # 构建输出
         has_data = False
@@ -518,11 +502,22 @@ def _interactive_config_setup(config_file_path: Path):
     env_vars = {}
     required_keys = platform_class.get_required_env_keys()
     defaults = platform_class.get_env_defaults()
+    config_guide = platform_class.get_env_config_guide()
     if required_keys:
         PrettyOutput.print(
             f"请输入 {platform_name} 平台所需的配置信息:", OutputType.INFO
         )
+
+        # 如果有配置指导，先显示总体说明
+        if config_guide:
+            PrettyOutput.print(f"\n配置获取方法:", OutputType.INFO)
+
         for key in required_keys:
+            # 显示该环境变量的配置指导
+            if key in config_guide and config_guide[key]:
+                PrettyOutput.print(f"\n{key} 获取方法:", OutputType.INFO)
+                PrettyOutput.print(config_guide[key], OutputType.INFO)
+
             default_value = defaults.get(key, "")
             prompt_text = f"  - {key}"
             if default_value:
@@ -998,11 +993,36 @@ def _pull_git_repo(repo_path: Path, repo_type: str):
             timeout=10,
         )
         if status_result.stdout:
-            PrettyOutput.print(
-                f"检测到 '{repo_path.name}' 存在未提交的更改，跳过自动更新。",
-                OutputType.WARNING,
-            )
-            return
+            if user_confirm(
+                f"检测到 '{repo_path.name}' 存在未提交的更改，是否放弃这些更改并更新？"
+            ):
+                try:
+                    subprocess.run(
+                        ["git", "checkout", "."],
+                        cwd=repo_path,
+                        capture_output=True,
+                        text=True,
+                        encoding="utf-8",
+                        errors="replace",
+                        check=True,
+                        timeout=10,
+                    )
+                except (
+                    subprocess.CalledProcessError,
+                    subprocess.TimeoutExpired,
+                    FileNotFoundError,
+                ) as e:
+                    PrettyOutput.print(
+                        f"放弃 '{repo_path.name}' 的更改失败: {str(e)}",
+                        OutputType.ERROR,
+                    )
+                    return
+            else:
+                PrettyOutput.print(
+                    f"跳过更新 '{repo_path.name}' 以保留未提交的更改。",
+                    OutputType.INFO,
+                )
+                return
 
         # 获取更新前的commit hash
         before_hash_result = subprocess.run(

{jarvis_ai_assistant-0.3.1.dist-info → jarvis_ai_assistant-0.3.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jarvis-ai-assistant
-Version: 0.3.1
+Version: 0.3.3
 Summary: Jarvis: An AI assistant that uses tools to interact with the system
 Home-page: https://github.com/skyfireitdiy/Jarvis
 Author: skyfire
@@ -202,27 +202,66 @@ iex ((New-Object System.Net.WebClient).DownloadString('https://raw.githubusercon
 
 #### 手动安装
 ```bash
+# 1. 克隆仓库
 git clone https://github.com/skyfireitdiy/Jarvis
+
+# 2. 进入项目目录
 cd Jarvis
+
+# 3. 安装项目为可编辑模式
 pip3 install -e .
 ```
+> **提示**: 使用 `-e .` (可编辑模式) 安装后，您对源码的任何修改都会立刻生效，非常适合开发者。
+
 或者从PyPI安装 (可能不是最新版):
 ```bash
 pip3 install jarvis-ai-assistant
 ```
 
+**通过 uv 安装 (推荐)**
+```bash
+# 1. 安装 uv (如果未安装)
+curl -LsSf https://astral.sh/uv/install.sh | sh
+
+# 2. 克隆仓库
+git clone https://github.com/skyfireitdiy/Jarvis
+
+# 3. 进入项目目录
+cd Jarvis
+
+# 4. 创建虚拟环境并安装
+uv venv
+
+# 安装基础功能
+uv pip install .
+
+# 可选: 安装RAG功能(包含PyTorch等较重的依赖)
+# uv pip install .[rag]
+```
+
+> **提示**: 安装完成后，建议将虚拟环境激活命令添加到您的 shell 配置文件中:
+> - Bash/Zsh: 在 ~/.bashrc 或 ~/.zshrc 中添加 `source /path/to/Jarvis/.venv/bin/activate`
+> - Fish: 在 ~/.config/fish/config.fish 中添加 `source /path/to/Jarvis/.venv/bin/activate.fish`
+
 ### 基本使用
 Jarvis 包含一系列专注于不同任务的工具。以下是主要命令及其快捷方式：
 
 | 命令 | 快捷方式 | 功能描述 |
 |------|----------|----------|
 | `jarvis` | `jvs` | 通用AI代理，适用于多种任务 |
+| `jarvis-agent` | `ja` | AI代理基础功能，处理会话和任务 |
 | `jarvis-code-agent` | `jca` | 专注于代码分析、修改和生成的代码代理 |
+| `jarvis-code-review` | `jcr` | 智能代码审查工具 |
 | `jarvis-git-commit` | `jgc` | 自动化分析代码变更并生成规范的Git提交信息 |
+| `jarvis-git-squash` | `jgs` | Git提交历史整理工具 |
 | `jarvis-platform-manager` | `jpm` | 管理和测试不同的大语言模型平台 |
+| `jarvis-multi-agent` | `jma` | 多智能体协作系统 |
+| `jarvis-tool` | `jt` | 工具管理与调用系统 |
+| `jarvis-methodology` | `jm` | 方法论知识库管理 |
 | `jarvis-rag` | `jrg` | 构建和查询本地化的RAG知识库 |
 | `jarvis-smart-shell` | `jss` | 实验性的智能Shell功能 |
 | `jarvis-stats` | `jst` | 通用统计模块，支持记录和可视化任意指标数据 |
+| `jarvis-memory-organizer` | `jmo` | 记忆管理工具，支持整理、合并、导入导出记忆 |
 
 更多详细用法和参数，请查阅我们的 [**使用指南**](docs/jarvis_book/4.使用指南.md)。