jarvis-ai-assistant 0.1.222__py3-none-any.whl → 0.7.0__py3-none-any.whl

jarvis/jarvis_agent/prompts.py

@@ -43,13 +43,28 @@ SUMMARY_REQUEST_PROMPT = """<summary_request>
 
 TASK_ANALYSIS_PROMPT = f"""<task_analysis>
 <request>
-当前任务已结束，请分析该任务的解决方案：
-1. 首先检查现有工具或方法论是否已经可以完成该任务，如果可以，直接说明即可，无需生成新内容
+当前任务已结束，请按以下步骤分析该任务：
+
+第一步：记忆值得保存的信息
+1. 识别任务中的关键信息和知识点
+2. 评估是否有值得保存的项目长期记忆或全局长期记忆
+3. 使用 save_memory 工具保存有价值的信息：
+   - project_long_term: 保存与当前项目相关的长期信息（如项目配置、架构决策、开发规范等）
+   - global_long_term: 保存通用的信息、用户偏好、知识或方法（如技术知识、最佳实践、用户习惯等）
+
+第二步：分析任务解决方案
+1. 检查现有工具或方法论是否已经可以完成该任务，如果可以，直接说明即可，无需生成新内容
 2. 如果现有工具/方法论不足，评估当前任务是否可以通过编写新工具来自动化解决
 3. 如果可以通过工具解决，请设计并提供工具代码
 4. 如果无法通过编写通用工具完成，评估当前的执行流程是否可以总结为通用方法论
 5. 如果以上都不可行，给出详细理由
-请根据分析结果采取相应行动：说明现有工具/方法论、创建新工具、生成新方法论或说明原因。
+
+请根据分析结果采取相应行动。
+
+重要提示：每次只能执行一个操作！
+- 如果有记忆需要保存，可以调用一次 save_memory 批量保存多条记忆
+- 保存完所有记忆后，再进行工具/方法论的创建或说明
+- 不要在一次响应中同时调用多个工具（如同时保存记忆和创建工具/方法论）
 </request>
 <evaluation_criteria>
 现有资源评估:
@@ -66,7 +81,7 @@ TASK_ANALYSIS_PROMPT = f"""<task_analysis>
 2. 方法论应该具备足够的通用性，可应用于同类问题
 3. 特别注意用户在执行过程中提供的修正、反馈和改进建议
 4. 如果用户明确指出了某个解决步骤的优化方向，这应该被纳入方法论
-5. 方法论要严格按照实际的执行流程来总结，不要遗漏或增加任何步骤
+5. 方法论应面向未来复用，总结“下次遇到同类问题应该如何处理”的通用流程与检查清单，避免局限于本次执行细节
 </evaluation_criteria>
 <tool_requirements>
 工具代码要求:
@@ -113,11 +128,36 @@ TASK_ANALYSIS_PROMPT = f"""<task_analysis>
            "stderr": f"操作失败: {{str(e)}}"
        }}
    ```
+4. **在工具中调用大模型**：如果工具需要调用大模型来完成子任务（例如，生成代码、分析文本等），为了避免干扰主对话流程，建议创建一个独立的大模型实例。
+   ```python
+    # 通过 agent 实例获取模型配置
+    agent = args.get("agent")
+    if not agent:
+        return {{"success": False, "stderr": "Agent not found."}}
+    
+    current_model = agent.model
+    platform_name = current_model.platform_name()
+    model_name = current_model.name()
+
+    # 创建独立的模型实例
+    from jarvis.jarvis_platform.registry import PlatformRegistry
+    llm = PlatformRegistry().create_platform(platform_name)
+    if not llm:
+        return {{"success": False, "stderr": f"Platform {{platform_name}} not found."}}
+    
+    llm.set_model_name(model_name)
+    llm.set_suppress_output(True) # 工具内的调用通常不需要流式输出
+
+    # 使用新实例调用大模型
+    PrettyOutput.print("正在执行子任务...", OutputType.INFO)
+    response = llm.chat_until_success("你的提示词")
+    PrettyOutput.print("子任务完成", OutputType.SUCCESS)
+   ```
 </tool_requirements>
 <methodology_requirements>
 方法论格式要求:
 1. 问题重述: 简明扼要的问题归纳，不含特定细节
-2. 最优解决方案: 经过用户验证的、最终有效的解决方案（将每个步骤要使用的工具也列举出来）
+2. 可复用解决流程: 面向“下次遇到同类问题”的步骤化方案（列出每步可用的工具），避免与本次特定上下文绑定
 3. 注意事项: 执行中可能遇到的常见问题和注意点，尤其是用户指出的问题
 4. 可选步骤: 对于有多种解决路径的问题，标注出可选步骤和适用场景
 </methodology_requirements>
@@ -139,10 +179,7 @@ arguments:
     from jarvis.jarvis_utils.output import PrettyOutput, OutputType
     class 工具名称:
         name = "工具名称"
-        description = "Tool for text transformation"
-                Tool description
-        适用场景：1. 格式化文本; 2. 处理标题; 3. 标准化输出
-        \"\"\"
+        description = "Tool description"
         parameters = {{
             "type": "object",
             "properties": {{

jarvis/jarvis_agent/protocols.py

@@ -1,7 +1,8 @@
 # -*- coding: utf-8 -*-
-from typing import Any, Protocol, Tuple
+from typing import Any, Protocol, Tuple, runtime_checkable
 
 
+@runtime_checkable
 class OutputHandlerProtocol(Protocol):
     """
     Defines the interface for an output handler, which is responsible for
@@ -28,3 +29,5 @@ class OutputHandlerProtocol(Protocol):
             A tuple containing a boolean (whether to return) and the result.
         """
         ...
+        
+__all__ = ["OutputHandlerProtocol"]

jarvis/jarvis_agent/rewrite_file_handler.py

@@ -0,0 +1,141 @@
+# -*- coding: utf-8 -*-
+import os
+import re
+from typing import Any, List, Tuple
+
+from jarvis.jarvis_agent.output_handler import OutputHandler
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+from jarvis.jarvis_utils.tag import ct, ot
+
+
+class RewriteFileHandler(OutputHandler):
+    """
+    处理整文件重写指令的输出处理器。
+
+    指令格式：
+    <REWRITE file=文件路径>
+    新的文件完整内容
+    </REWRITE>
+
+    等价支持以下写法：
+    <REWRITE file=文件路径>
+    新的文件完整内容
+    </REWRITE>
+
+    说明：
+    - 该处理器用于完全重写文件内容，适用于新增文件或大范围改写
+    - 内部直接执行写入，提供失败回滚能力
+    - 支持同一响应中包含多个 REWRITE/REWRITE 块
+    """
+
+    def __init__(self) -> None:
+        # 允许 file 参数为单引号、双引号或无引号
+        self.rewrite_pattern_file = re.compile(
+            ot("REWRITE file=(?:'([^']+)'|\"([^\"]+)\"|([^>]+))")
+            + r"\s*"
+            + r"(.*?)"
+            + r"\s*"
+            + r"^"
+            + ct("REWRITE"),
+            re.DOTALL | re.MULTILINE,
+        )
+
+    def name(self) -> str:
+        """获取处理器名称，用于操作列表展示"""
+        return "REWRITE"
+
+    def prompt(self) -> str:
+        """返回用户提示，描述使用方法与格式"""
+        return f"""文件重写指令格式：
+{ot("REWRITE file=文件路径")}
+新的文件完整内容
+{ct("REWRITE")}
+
+注意：
+- {ot("REWRITE")}、{ct("REWRITE")} 必须出现在行首，否则不生效（会被忽略）
+- 整文件重写会完全替换文件内容，如需局部修改请使用 PATCH 操作
+- 该操作由处理器直接执行，具备失败回滚能力"""
+
+    def can_handle(self, response: str) -> bool:
+        """判断响应中是否包含 REWRITE/REWRITE 指令"""
+        return bool(self.rewrite_pattern_file.search(response))
+
+    def handle(self, response: str, agent: Any) -> Tuple[bool, str]:
+        """解析并执行整文件重写指令"""
+        rewrites = self._parse_rewrites(response)
+        if not rewrites:
+            return False, "未找到有效的文件重写指令"
+
+        # 记录 REWRITE 操作调用统计
+        try:
+            from jarvis.jarvis_stats.stats import StatsManager
+
+            StatsManager.increment("rewrite_file", group="tool")
+        except Exception:
+            # 统计失败不影响主流程
+            pass
+
+        results: List[str] = []
+
+        for file_path, content in rewrites:
+            abs_path = os.path.abspath(file_path)
+            original_content = None
+            processed = False
+            try:
+                file_exists = os.path.exists(abs_path)
+                if file_exists:
+                    with open(abs_path, "r", encoding="utf-8") as rf:
+                        original_content = rf.read()
+                os.makedirs(os.path.dirname(abs_path), exist_ok=True)
+                with open(abs_path, "w", encoding="utf-8") as wf:
+                    wf.write(content)
+                processed = True
+                results.append(f"✅ 文件 {abs_path} 重写成功")
+                # 记录成功处理的文件（使用绝对路径）
+                if agent:
+                    files = agent.get_user_data("files")
+                    if files:
+                        if abs_path not in files:
+                            files.append(abs_path)
+                    else:
+                        files = [abs_path]
+                    agent.set_user_data("files", files)
+            except Exception as e:
+                # 回滚已修改内容
+                try:
+                    if processed:
+                        if original_content is None:
+                            if os.path.exists(abs_path):
+                                os.remove(abs_path)
+                        else:
+                            with open(abs_path, "w", encoding="utf-8") as wf:
+                                wf.write(original_content)
+                except Exception:
+                    pass
+                PrettyOutput.print(f"文件重写失败: {str(e)}", OutputType.ERROR)
+                results.append(f"❌ 文件 {abs_path} 重写失败: {str(e)}")
+
+        summary = "\n".join(results)
+        # 按现有 EditFileHandler 约定，始终返回 (False, summary) 以继续主循环
+        return False, summary
+
+    def _parse_rewrites(self, response: str) -> List[Tuple[str, str]]:
+        """
+        解析响应中的 REWRITE/REWRITE 指令块。
+        返回列表 [(file_path, content), ...]，按在响应中的出现顺序排序
+        """
+        items: List[Tuple[str, str]] = []
+        matches: List[Tuple[int, Any]] = []
+        for m in self.rewrite_pattern_file.finditer(response):
+            matches.append((m.start(), m))
+
+        # 按出现顺序排序
+        matches.sort(key=lambda x: x[0])
+
+        for _, m in matches:
+            file_path = m.group(1) or m.group(2) or m.group(3) or ""
+            file_path = file_path.strip()
+            content = m.group(4)
+            if file_path:
+                items.append((file_path, content))
+        return items

jarvis/jarvis_agent/run_loop.py

@@ -0,0 +1,146 @@
+# -*- coding: utf-8 -*-
+"""
+AgentRunLoop: 承载 Agent 的主运行循环逻辑。
+
+阶段一目标（最小变更）：
+- 复制现有 _main_loop 逻辑到独立类，使用传入的 agent 实例进行委派调用
+- 暂不变更外部调用入口，后续在 Agent._main_loop 中委派到该类
+- 保持与现有异常处理、工具调用、用户交互完全一致
+"""
+import os
+from enum import Enum
+from typing import Any, TYPE_CHECKING
+
+from jarvis.jarvis_utils.output import OutputType, PrettyOutput
+from jarvis.jarvis_agent.events import BEFORE_TOOL_CALL, AFTER_TOOL_CALL
+from jarvis.jarvis_agent.utils import join_prompts, is_auto_complete, normalize_next_action
+from jarvis.jarvis_utils.config import get_auto_summary_rounds
+
+if TYPE_CHECKING:
+    # 仅用于类型标注，避免运行时循环依赖
+    from . import Agent  # noqa: F401
+
+
+class AgentRunLoop:
+    def __init__(self, agent: "Agent") -> None:
+        self.agent = agent
+        self.conversation_rounds = 0
+        self.tool_reminder_rounds = int(os.environ.get("JARVIS_TOOL_REMINDER_ROUNDS", 20))
+        # 基于轮次的自动总结阈值：优先使用 Agent 入参，否则回落到全局配置（默认20轮）
+        self.auto_summary_rounds = (
+            self.agent.auto_summary_rounds
+            if getattr(self.agent, "auto_summary_rounds", None) is not None
+            else get_auto_summary_rounds()
+        )
+
+    def run(self) -> Any:
+        """主运行循环（委派到传入的 agent 实例的方法与属性）"""
+        run_input_handlers = True
+
+        while True:
+            try:
+                self.conversation_rounds += 1
+                if self.conversation_rounds % self.tool_reminder_rounds == 0:
+                    self.agent.session.addon_prompt = join_prompts(
+                        [self.agent.session.addon_prompt, self.agent.get_tool_usage_prompt()]
+                    )
+                # 基于轮次的自动总结判断：达到阈值后执行一次总结与历史清理
+                if self.conversation_rounds >= self.auto_summary_rounds:
+                    summary_text = self.agent._summarize_and_clear_history()
+                    if summary_text:
+                        # 将摘要作为下一轮的附加提示加入，从而维持上下文连续性
+                        self.agent.session.addon_prompt = join_prompts(
+                            [self.agent.session.addon_prompt, summary_text]
+                        )
+                    # 重置轮次计数与对话长度计数器，开始新一轮周期
+                    self.conversation_rounds = 0
+                    self.agent.session.conversation_length = 0
+
+                ag = self.agent
+
+                # 更新输入处理器标志
+                if ag.run_input_handlers_next_turn:
+                    run_input_handlers = True
+                    ag.run_input_handlers_next_turn = False
+
+                # 首次运行初始化
+                if ag.first:
+                    ag._first_run()
+
+                # 调用模型获取响应
+                current_response = ag._call_model(
+                    ag.session.prompt, True, run_input_handlers
+                )
+
+                ag.session.prompt = ""
+                run_input_handlers = False
+
+                # 处理中断
+                interrupt_result = ag._handle_run_interrupt(current_response)
+                if (
+                    isinstance(interrupt_result, Enum)
+                    and getattr(interrupt_result, "value", None) == "skip_turn"
+                ):
+                    # 中断处理器请求跳过本轮剩余部分，直接开始下一次循环
+                    continue
+                elif interrupt_result is not None and not isinstance(interrupt_result, Enum):
+                    # 中断处理器返回了最终结果，任务结束
+                    return interrupt_result
+
+                # 处理工具调用
+                # 广播工具调用前事件（不影响主流程）
+                try:
+                    ag.event_bus.emit(
+                        BEFORE_TOOL_CALL,
+                        agent=ag,
+                        current_response=current_response,
+                    )
+                except Exception:
+                    pass
+                need_return, tool_prompt = ag._call_tools(current_response)
+
+                # 如果工具要求立即返回结果（例如 SEND_MESSAGE 需要将字典返回给上层），直接返回该结果
+                if need_return:
+                    return tool_prompt
+
+                # 将上一个提示和工具提示安全地拼接起来（仅当工具结果为字符串时）
+                safe_tool_prompt = tool_prompt if isinstance(tool_prompt, str) else ""
+                ag.session.prompt = join_prompts([ag.session.prompt, safe_tool_prompt])
+
+                # 广播工具调用后的事件（不影响主流程）
+                try:
+                    ag.event_bus.emit(
+                        AFTER_TOOL_CALL,
+                        agent=ag,
+                        current_response=current_response,
+                        need_return=need_return,
+                        tool_prompt=tool_prompt,
+                    )
+                except Exception:
+                    pass
+
+                # 检查是否需要继续
+                if ag.session.prompt or ag.session.addon_prompt:
+                    continue
+
+                # 检查自动完成
+                if ag.auto_complete and is_auto_complete(current_response):
+                    # 先运行_complete_task，触发记忆整理/事件等副作用，再决定返回值
+                    result = ag._complete_task(auto_completed=True)
+                    # 若不需要summary，则将最后一条LLM输出作为返回值
+                    if not getattr(ag, "need_summary", True):
+                        return current_response
+                    return result
+
+                # 获取下一步用户输入
+                next_action = ag._get_next_user_action()
+                action = normalize_next_action(next_action)
+                if action == "continue":
+                    run_input_handlers = True
+                    continue
+                elif action == "complete":
+                    return ag._complete_task(auto_completed=False)
+
+            except Exception as e:
+                PrettyOutput.print(f"任务失败: {str(e)}", OutputType.ERROR)
+                return f"Task failed: {str(e)}"

jarvis/jarvis_agent/session_manager.py

@@ -34,14 +34,6 @@ class SessionManager:
         """Sets the addon prompt for the next model call."""
         self.addon_prompt = addon_prompt
 
-    def clear(self):
-        """
-        Clears the current conversation history, prompt, and length counter.
-        """
-        self.model.reset()
-        self.conversation_length = 0
-        self.prompt = ""
-
     def save_session(self) -> bool:
         """Saves the current session state to a file."""
         session_dir = os.path.join(os.getcwd(), ".jarvis")
@@ -75,10 +67,18 @@ class SessionManager:
             return True
         return False
 
-    def clear_history(self):
+    def clear_history(self) -> None:
         """
         Clears conversation history but keeps the system prompt by resetting the model state.
         """
         self.prompt = ""
         self.model.reset()
         self.conversation_length = 0
+
+    def clear(self) -> None:
+        """
+        Clears the session state, resetting prompt and conversation length while
+        preserving user_data. This method is an alias of clear_history for backward
+        compatibility with existing tests and callers.
+        """
+        self.clear_history()

jarvis/jarvis_agent/share_manager.py

@@ -0,0 +1,228 @@
+# -*- coding: utf-8 -*-
+"""分享管理模块，负责工具和方法论的分享功能"""
+import os
+import subprocess
+from typing import List, Dict, Any, Set
+from abc import ABC, abstractmethod
+
+from prompt_toolkit import prompt
+
+from jarvis.jarvis_agent import OutputType, PrettyOutput, user_confirm
+from jarvis.jarvis_utils.config import get_data_dir
+
+
+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))
+
+
+class ShareManager(ABC):
+    """分享管理器基类"""
+
+    def __init__(self, central_repo_url: str, repo_name: str):
+        self.central_repo_url = central_repo_url
+        self.repo_name = repo_name
+        # 支持将中心仓库配置为本地目录（含git子路径）
+        expanded = os.path.expanduser(os.path.expandvars(central_repo_url))
+        if os.path.isdir(expanded):
+            # 直接使用本地目录作为中心仓库路径（支持git仓库子目录）
+            self.repo_path = expanded
+        else:
+            # 仍按原逻辑使用数据目录中的克隆路径
+            self.repo_path = os.path.join(get_data_dir(), repo_name)
+
+    def update_central_repo(self) -> None:
+        """克隆或更新中心仓库"""
+        if not os.path.exists(self.repo_path):
+            PrettyOutput.print(
+                f"正在克隆中心{self.get_resource_type()}仓库...", OutputType.INFO
+            )
+            subprocess.run(
+                ["git", "clone", self.central_repo_url, self.repo_path], check=True
+            )
+            # 检查并添加.gitignore文件
+            gitignore_path = os.path.join(self.repo_path, ".gitignore")
+            modified = False
+            if not os.path.exists(gitignore_path):
+                with open(gitignore_path, "w") as f:
+                    f.write("__pycache__/\n")
+                modified = True
+            else:
+                with open(gitignore_path, "r+") as f:
+                    content = f.read()
+                    if "__pycache__" not in content:
+                        f.write("\n__pycache__/\n")
+                        modified = True
+
+            if modified:
+                subprocess.run(
+                    ["git", "add", ".gitignore"], cwd=self.repo_path, check=True
+                )
+                subprocess.run(
+                    ["git", "commit", "-m", "chore: add __pycache__ to .gitignore"],
+                    cwd=self.repo_path,
+                    check=True,
+                )
+                subprocess.run(["git", "push"], cwd=self.repo_path, check=True)
+        else:
+            PrettyOutput.print(
+                f"正在更新中心{self.get_resource_type()}仓库...", OutputType.INFO
+            )
+            # 检查是否是空仓库
+            try:
+                # 先尝试获取远程分支信息
+                result = subprocess.run(
+                    ["git", "ls-remote", "--heads", "origin"],
+                    cwd=self.repo_path,
+                    capture_output=True,
+                    text=True,
+                    check=True,
+                )
+                # 如果有远程分支，执行pull
+                if result.stdout.strip():
+                    # 检查是否有未提交的更改
+                    status_result = subprocess.run(
+                        ["git", "status", "--porcelain"],
+                        cwd=self.repo_path,
+                        capture_output=True,
+                        text=True,
+                        check=True,
+                    )
+                    if status_result.stdout:
+                        if user_confirm(
+                            f"检测到中心{self.get_resource_type()}仓库 '{self.repo_name}' 存在未提交的更改，是否放弃这些更改并更新？"
+                        ):
+                            subprocess.run(
+                                ["git", "checkout", "."], cwd=self.repo_path, check=True
+                            )
+                        else:
+                            PrettyOutput.print(
+                                f"跳过更新 '{self.repo_name}' 以保留未提交的更改。",
+                                OutputType.INFO,
+                            )
+                            return
+                    subprocess.run(["git", "pull"], cwd=self.repo_path, check=True)
+                else:
+                    PrettyOutput.print(
+                        f"中心{self.get_resource_type()}仓库是空的，将初始化为新仓库",
+                        OutputType.INFO,
+                    )
+            except subprocess.CalledProcessError:
+                # 如果命令失败，可能是网络问题或其他错误
+                PrettyOutput.print("无法连接到远程仓库，将跳过更新", OutputType.WARNING)
+
+    def commit_and_push(self, count: int) -> None:
+        """提交并推送更改"""
+        PrettyOutput.print("\n正在提交更改...", OutputType.INFO)
+        subprocess.run(["git", "add", "."], cwd=self.repo_path, check=True)
+
+        commit_msg = f"Add {count} {self.get_resource_type()}(s) from local collection"
+        subprocess.run(
+            ["git", "commit", "-m", commit_msg], cwd=self.repo_path, check=True
+        )
+
+        PrettyOutput.print("正在推送到远程仓库...", OutputType.INFO)
+        # 检查是否需要设置上游分支（空仓库的情况）
+        try:
+            # 先尝试普通推送
+            subprocess.run(["git", "push"], cwd=self.repo_path, check=True)
+        except subprocess.CalledProcessError:
+            # 如果失败，可能是空仓库，尝试设置上游分支
+            try:
+                subprocess.run(
+                    ["git", "push", "-u", "origin", "main"],
+                    cwd=self.repo_path,
+                    check=True,
+                )
+            except subprocess.CalledProcessError:
+                # 如果main分支不存在，尝试master分支
+                subprocess.run(
+                    ["git", "push", "-u", "origin", "master"],
+                    cwd=self.repo_path,
+                    check=True,
+                )
+
+    def select_resources(self, resources: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """让用户选择要分享的资源"""
+        # 显示可选的资源
+        resource_list = [
+            f"\n可分享的{self.get_resource_type()}（已排除中心仓库中已有的）："
+        ]
+        for i, resource in enumerate(resources, 1):
+            resource_list.append(f"[{i}] {self.format_resource_display(resource)}")
+
+        # 一次性打印所有资源
+        PrettyOutput.print("\n".join(resource_list), OutputType.INFO)
+
+        # 让用户选择
+        while True:
+            try:
+                choice_str = prompt(
+                    f"\n请选择要分享的{self.get_resource_type()}编号（支持格式: 1,2,3,4-9,20 或 all）："
+                ).strip()
+                if choice_str == "0":
+                    return []
+
+                if choice_str.lower() == "all":
+                    return resources
+                else:
+                    selected_indices = parse_selection(choice_str, len(resources))
+                    if not selected_indices:
+                        PrettyOutput.print("无效的选择", OutputType.WARNING)
+                        continue
+                    return [resources[i - 1] for i in selected_indices]
+
+            except ValueError:
+                PrettyOutput.print("请输入有效的数字", OutputType.WARNING)
+
+    @abstractmethod
+    def get_resource_type(self) -> str:
+        """获取资源类型名称"""
+        pass
+
+    @abstractmethod
+    def format_resource_display(self, resource: Dict[str, Any]) -> str:
+        """格式化资源显示"""
+        pass
+
+    @abstractmethod
+    def get_existing_resources(self) -> Any:
+        """获取中心仓库中已有的资源"""
+        pass
+
+    @abstractmethod
+    def get_local_resources(self) -> List[Dict[str, Any]]:
+        """获取本地资源"""
+        pass
+
+    @abstractmethod
+    def share_resources(self, resources: List[Dict[str, Any]]) -> List[str]:
+        """分享资源到中心仓库"""
+        pass