fr-cli 2.2.9__tar.gz → 2.3.0__tar.gz

{fr_cli-2.2.9/fr_cli.egg-info → fr_cli-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fr-cli
-Version: 2.2.9
+Version: 2.3.0
 Summary: 凡人打字机 - 支持多模型(Zhipu/DeepSeek/Kimi/Qwen/StepFun/MiniMax/Spark/Doubao/MiMo)的终极全能终端工具
 Author: FANREN CLI Author
 License-Expression: MIT

fr_cli-2.3.0/fr_cli/agent/context_files.py

@@ -0,0 +1,159 @@
+"""
+Context Files 系统 - 参考 Hermes Agent 实现
+项目上下文文件，塑造每次对话
+"""
+
+import os
+import glob
+from typing import List, Dict, Optional
+from dataclasses import dataclass
+
+
+@dataclass
+class ContextFile:
+    """上下文文件"""
+    path: str
+    content: str = ""
+    size: int = 0
+    loaded: bool = False
+
+    def load_content(self):
+        """加载文件内容"""
+        if not self.loaded and os.path.exists(self.path):
+            try:
+                with open(self.path, 'r', encoding='utf-8') as f:
+                    self.content = f.read(100000)  # 限制 100KB
+                    self.size = len(self.content)
+                    self.loaded = True
+            except Exception:
+                pass
+
+
+class ContextFilesManager:
+    """上下文文件管理器"""
+
+    def __init__(self, config_dir: str = None):
+        if config_dir is None:
+            config_dir = os.path.expanduser("~/.fr_cli")
+        self.config_dir = config_dir
+        self.context_file = os.path.join(config_dir, "context_files.json")
+        self.patterns: List[str] = []
+        self.exclude_patterns: List[str] = [".git/*", "node_modules/*", "__pycache__/*"]
+        self._load_config()
+
+    def _load_config(self):
+        """加载配置"""
+        if os.path.exists(self.context_file):
+            try:
+                import json
+                with open(self.context_file, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                    self.patterns = data.get("patterns", [])
+                    self.exclude_patterns = data.get("exclude", self.exclude_patterns)
+            except Exception:
+                pass
+
+    def _save_config(self):
+        """保存配置"""
+        import json
+        os.makedirs(os.path.dirname(self.context_file), exist_ok=True)
+        with open(self.context_file, 'w', encoding='utf-8') as f:
+            json.dump({
+                "patterns": self.patterns,
+                "exclude": self.exclude_patterns
+            }, f, indent=2)
+
+    def add_pattern(self, pattern: str):
+        """添加匹配模式"""
+        if pattern not in self.patterns:
+            self.patterns.append(pattern)
+            self._save_config()
+
+    def remove_pattern(self, pattern: str):
+        """移除匹配模式"""
+        if pattern in self.patterns:
+            self.patterns.remove(pattern)
+            self._save_config()
+
+    def add_exclude(self, pattern: str):
+        """添加排除模式"""
+        if pattern not in self.exclude_patterns:
+            self.exclude_patterns.append(pattern)
+            self._save_config()
+
+    def get_matching_files(self, root_dir: str = ".") -> List[str]:
+        """获取匹配的文件列表"""
+        files = set()
+
+        for pattern in self.patterns:
+            full_pattern = os.path.join(root_dir, pattern)
+            matched = glob.glob(full_pattern, recursive=True)
+            files.update(matched)
+
+        # 应用排除
+        excluded = set()
+        for exclude in self.exclude_patterns:
+            full_exclude = os.path.join(root_dir, exclude)
+            matched = glob.glob(full_exclude, recursive=True)
+            excluded.update(matched)
+
+        return [f for f in files if f not in excluded]
+
+    def load_context_files(self, root_dir: str = ".") -> List[ContextFile]:
+        """加载所有上下文文件"""
+        files = self.get_matching_files(root_dir)
+        context_files = []
+
+        for filepath in files:
+            cf = ContextFile(path=filepath)
+            cf.load_content()
+            if cf.loaded:
+                context_files.append(cf)
+
+        return context_files
+
+    def build_context_prompt(self, root_dir: str = ".") -> str:
+        """构建上下文提示"""
+        context_files = self.load_context_files(root_dir)
+        if not context_files:
+            return ""
+
+        parts = ["\n\n# 项目上下文\n"]
+
+        for cf in context_files:
+            parts.append(f"\n## {os.path.relpath(cf.path, root_dir)}")
+            parts.append(f"```\n{cf.content}\n```")
+
+        return "\n".join(parts)
+
+    def list_patterns(self) -> Dict:
+        """列出所有模式"""
+        return {
+            "include": self.patterns,
+            "exclude": self.exclude_patterns
+        }
+
+    def set_patterns(self, patterns: List[str]):
+        """设置包含模式"""
+        self.patterns = patterns
+        self._save_config()
+
+    def set_exclude_patterns(self, patterns: List[str]):
+        """设置排除模式"""
+        self.exclude_patterns = patterns
+        self._save_config()
+
+
+# 全局实例
+_context_manager = None
+
+def get_context_manager() -> ContextFilesManager:
+    global _context_manager
+    if _context_manager is None:
+        _context_manager = ContextFilesManager()
+    return _context_manager
+
+
+def build_project_context(root_dir: str = ".") -> str:
+    """构建项目上下文"""
+    return get_context_manager().build_context_prompt(root_dir)

fr_cli-2.3.0/fr_cli/agent/gateway.py

@@ -0,0 +1,233 @@
+"""
+Gateway 功能 - 多平台消息网关
+参考 Hermes Agent 实现
+支持 Telegram、Discord、Slack 等平台
+"""
+
+import os
+import asyncio
+import json
+from typing import Dict, Optional
+from dataclasses import dataclass
+from enum import Enum
+
+
+class Platform(Enum):
+    """支持的平台"""
+    TELEGRAM = "telegram"
+    DISCORD = "discord"
+    SLACK = "slack"
+    CLI = "cli"
+
+
+@dataclass
+class GatewayConfig:
+    """网关配置"""
+    platform: Platform
+    enabled: bool = False
+    bot_token: Optional[str] = None
+    api_key: Optional[str] = None
+    chat_id: Optional[str] = None
+
+
+class GatewayManager:
+    """网关管理器"""
+
+    def __init__(self):
+        self.config_file = os.path.expanduser("~/.fr_cli/gateway.json")
+        self.platforms: Dict[str, GatewayConfig] = {}
+        self._load_config()
+        self._running = False
+
+    def _load_config(self):
+        """加载配置"""
+        if os.path.exists(self.config_file):
+            try:
+                with open(self.config_file) as f:
+                    data = json.load(f)
+                    for name, cfg in data.items():
+                        self.platforms[name] = GatewayConfig(
+                            platform=Platform(cfg.get("platform", "cli")),
+                            enabled=cfg.get("enabled", False),
+                            bot_token=cfg.get("bot_token"),
+                            api_key=cfg.get("api_key"),
+                            chat_id=cfg.get("chat_id")
+                        )
+            except Exception:
+                pass
+
+    def _save_config(self):
+        """保存配置"""
+        os.makedirs(os.path.dirname(self.config_file), exist_ok=True)
+        data = {}
+        for name, cfg in self.platforms.items():
+            data[name] = {
+                "platform": cfg.platform.value,
+                "enabled": cfg.enabled,
+                "bot_token": cfg.bot_token,
+                "api_key": cfg.api_key,
+                "chat_id": cfg.chat_id
+            }
+        with open(self.config_file, 'w') as f:
+            json.dump(data, f, indent=2)
+
+    def configure_telegram(self, bot_token: str, allowed_chat_ids: list = None):
+        """配置 Telegram"""
+        self.platforms["telegram"] = GatewayConfig(
+            platform=Platform.TELEGRAM,
+            enabled=True,
+            bot_token=bot_token,
+            chat_id=json.dumps(allowed_chat_ids or [])
+        )
+        self._save_config()
+        print("✅ Telegram 配置完成")
+        print("   使用 /gateway start telegram 启动")
+
+    def configure_discord(self, bot_token: str, guild_id: str = None):
+        """配置 Discord"""
+        self.platforms["discord"] = GatewayConfig(
+            platform=Platform.DISCORD,
+            enabled=True,
+            bot_token=bot_token,
+            chat_id=guild_id
+        )
+        self._save_config()
+        print("✅ Discord 配置完成")
+        print("   使用 /gateway start discord 启动")
+
+    def list_platforms(self):
+        """列出已配置的平台"""
+        print("\n📱 已配置的消息平台:")
+        if not self.platforms:
+            print("   (无)")
+            return
+
+        for name, cfg in self.platforms.items():
+            status = "✅ 启用" if cfg.enabled else "❌ 禁用"
+            print(f"   {name}: {status}")
+        print()
+
+    async def start_telegram(self):
+        """启动 Telegram Bot"""
+        cfg = self.platforms.get("telegram")
+        if not cfg or not cfg.enabled:
+            print("❌ Telegram 未配置")
+            return
+
+        try:
+            from telegram import Bot
+            from telegram.ext import Application, CommandHandler, MessageHandler, filters
+
+            bot = Bot(token=cfg.bot_token)
+
+            async def handle_message(update, context):
+                from fr_cli.core.core import ask
+                message = update.message.text
+                result, _ = await asyncio.to_thread(ask, message)
+                await update.message.reply_text(result)
+
+            app = Application.builder().token(cfg.bot_token).build()
+            app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_message))
+            print("🤖 Telegram Bot 已启动!")
+            await app.run_polling()
+
+        except ImportError:
+            print("❌ 需要安装 python-telegram-bot: pip install python-telegram-bot")
+        except Exception as e:
+            print(f"❌ Telegram 启动失败: {e}")
+
+    async def start_discord(self):
+        """启动 Discord Bot"""
+        cfg = self.platforms.get("discord")
+        if not cfg or not cfg.enabled:
+            print("❌ Discord 未配置")
+            return
+
+        try:
+            import discord
+
+            intents = discord.Intents.default()
+            intents.message_content = True
+            client = discord.Client(intents=intents)
+
+            @client.event
+            async def on_message(message):
+                if message.author == client.user:
+                    return
+
+                from fr_cli.core.core import ask
+                result, _ = await asyncio.to_thread(ask, message.content)
+                await message.channel.send(result)
+
+            print("📢 Discord Bot 已启动!")
+            await client.start(cfg.bot_token)
+
+        except ImportError:
+            print("❌ 需要安装 discord.py: pip install discord.py")
+        except Exception as e:
+            print(f"❌ Discord 启动失败: {e}")
+
+    async def start_all(self):
+        """启动所有已配置的平台"""
+        tasks = []
+        if "telegram" in self.platforms and self.platforms["telegram"].enabled:
+            tasks.append(self.start_telegram())
+        if "discord" in self.platforms and self.platforms["discord"].enabled:
+            tasks.append(self.start_discord())
+
+        if tasks:
+            await asyncio.gather(*tasks)
+        else:
+            print("❌ 没有已启用的平台")
+
+    def stop(self):
+        """停止网关"""
+        self._running = False
+        print("🛑 网关已停止")
+
+
+def run_gateway(platform: str = None):
+    """运行网关"""
+    manager = GatewayManager()
+
+    if platform:
+        if platform == "telegram":
+            asyncio.run(manager.start_telegram())
+        elif platform == "discord":
+            asyncio.run(manager.start_discord())
+        else:
+            print(f"❌ 不支持的平台: {platform}")
+    else:
+        asyncio.run(manager.start_all())
+
+
+# CLI 命令
+if __name__ == "__main__":
+    import sys
+    if len(sys.argv) > 1:
+        if sys.argv[1] == "start":
+            platform = sys.argv[2] if len(sys.argv) > 2 else None
+            run_gateway(platform)
+        elif sys.argv[1] == "setup":
+            manager = GatewayManager()
+            manager.list_platforms()
+        else:
+            print("用法: fr gateway [start|setup] [platform]")
+    else:
+        print("""
+╔════════════════════════════════════════════════════╗
+║           fr-cli Gateway 消息网关                 ║
+╚════════════════════════════════════════════════════╝
+
+用法:
+  fr gateway setup                    查看已配置的平台
+  fr gateway start telegram           启动 Telegram Bot
+  fr gateway start discord           启动 Discord Bot
+  fr gateway start                   启动所有平台
+
+配置示例:
+  from fr_cli.agent.gateway import GatewayManager
+  gm = GatewayManager()
+  gm.configure_telegram("your-bot-token")
+  gm.configure_discord("your-bot-token")
+        """)

{fr_cli-2.2.9 → fr_cli-2.3.0}/fr_cli/agent/hermes.py

@@ -1,6 +1,16 @@
 """
 Hermes 功能模块
 参考 NousResearch/hermes-agent 实现核心功能
+
+整合:
+- TaskManager: 任务管理
+- Analytics: 分析统计
+- GoalTracker: 目标追踪
+- ConfigManager: 配置管理
+- CronScheduler: 定时任务
+- SkillManager: 技能系统 (见 skills.py)
+- PersonalityManager: 个性系统 (见 personality.py)
+- ContextFilesManager: 上下文文件 (见 context_files.py)
 """
 
 import os

fr_cli-2.3.0/fr_cli/agent/personality.py

@@ -0,0 +1,236 @@
+"""
+Personality 系统 - 参考 Hermes Agent 实现
+支持多种 AI 个性切换
+"""
+
+import os
+import json
+from typing import Dict, Optional
+from dataclasses import dataclass
+
+
+@dataclass
+class Personality:
+    """AI 个性"""
+    name: str
+    description: str
+    identity: str
+    system_prompt: str
+    examples: list = None
+
+    def __post_init__(self):
+        if self.examples is None:
+            self.examples = []
+
+    def to_dict(self) -> Dict:
+        return {
+            "name": self.name,
+            "description": self.description,
+            "identity": self.identity,
+            "system_prompt": self.system_prompt,
+            "examples": self.examples
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict) -> 'Personality':
+        return cls(**data)
+
+
+class PersonalityManager:
+    """个性管理器"""
+
+    def __init__(self, config_dir: str = None):
+        if config_dir is None:
+            config_dir = os.path.expanduser("~/.fr_cli")
+        self.config_dir = config_dir
+        self.personalities: Dict[str, Personality] = {}
+        self.current_personality: Optional[Personality] = None
+        self._load_personalities()
+
+    def _get_personalities_file(self) -> str:
+        return os.path.join(self.config_dir, "personalities.json")
+
+    def _load_personalities(self):
+        """加载内置和用户个性"""
+        self._register_builtin_personalities()
+
+        config_file = self._get_personalities_file()
+        if os.path.exists(config_file):
+            try:
+                with open(config_file, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                    for name, cfg in data.items():
+                        self.personalities[name] = Personality.from_dict(cfg)
+            except Exception:
+                pass
+
+        if not self.current_personality and self.personalities:
+            self.current_personality = list(self.personalities.values())[0]
+
+    def _register_builtin_personalities(self):
+        """注册内置个性"""
+        self.personalities = {
+            "default": Personality(
+                name="default",
+                description="默认助手",
+                identity="你是一个有帮助的 AI 助手。",
+                system_prompt="你是一个有帮助的 AI 助手，擅长回答各种问题。"
+            ),
+            "coder": Personality(
+                name="coder",
+                description="编程专家",
+                identity="你是一个专业的程序员。",
+                system_prompt="""你是一个专业的程序员，擅长:
+- Python, JavaScript, TypeScript, Go, Rust 等语言
+- 代码审查和优化
+- 调试和错误修复
+- 设计模式和架构建议
+- 编写测试和文档""",
+                examples=["帮我写一个排序算法", "这段代码有什么问题?"]
+            ),
+            "reviewer": Personality(
+                name="reviewer",
+                description="代码审查员",
+                identity="你是一个严格的代码审查员。",
+                system_prompt="""你是一个严格的代码审查员，关注:
+- 代码质量和可读性
+- 性能和效率
+- 安全漏洞
+- 最佳实践
+- 潜在的 bug
+
+给出具体、可操作的改进建议。""",
+                examples=["审查这段代码", "有什么安全问题?"]
+            ),
+            "teacher": Personality(
+                name="teacher",
+                description="编程教师",
+                identity="你是一个耐心的编程教师。",
+                system_prompt="""你是一个耐心的编程教师，特点:
+- 解释清晰易懂
+- 提供例子和类比
+- 循序渐进
+- 鼓励学习者
+- 耐心回答问题""",
+                examples=["解释什么是闭包", "面向对象是什么?"]
+            ),
+            "expert": Personality(
+                name="expert",
+                description="领域专家",
+                identity="你是一个各个领域的专家。",
+                system_prompt="""你是一个广博的领域专家，可以提供:
+- 深入的技术分析
+- 行业洞察
+- 战略建议
+- 最佳实践
+- 前沿趋势""",
+                examples=["分析这个架构的优缺点", "给我一些战略建议"]
+            ),
+            "creative": Personality(
+                name="creative",
+                description="创意助手",
+                identity="你是一个富有创意的助手。",
+                system_prompt="""你是一个富有创意的助手，擅长:
+- 头脑风暴
+- 生成创意点子
+- 写作和内容创作
+- 解决棘手问题
+- 提供新颖的解决方案""",
+                examples=["给我一些创意点子", "怎么让这个产品更有趣?"]
+            )
+        }
+
+    def _save_personalities(self):
+        """保存用户个性"""
+        config_file = self._get_personalities_file()
+        os.makedirs(os.path.dirname(config_file), exist_ok=True)
+        data = {
+            name: p.to_dict()
+            for name, p in self.personalities.items()
+            if name not in ["default", "coder", "reviewer", "teacher", "expert", "creative"]
+        }
+        if data:
+            with open(config_file, 'w', encoding='utf-8') as f:
+                json.dump(data, f, ensure_ascii=False, indent=2)
+
+    def set_personality(self, name: str) -> bool:
+        """设置当前个性"""
+        if name in self.personalities:
+            self.current_personality = self.personalities[name]
+            return True
+        return False
+
+    def get_current(self) -> Optional[Personality]:
+        """获取当前个性"""
+        return self.current_personality
+
+    def add_personality(self, personality: Personality):
+        """添加用户个性"""
+        self.personalities[personality.name] = personality
+        self._save_personalities()
+
+    def remove_personality(self, name: str) -> bool:
+        """删除用户个性"""
+        if name in ["default", "coder", "reviewer", "teacher", "expert", "creative"]:
+            return False
+        if name in self.personalities:
+            del self.personalities[name]
+            if self.current_personality and self.current_personality.name == name:
+                self.current_personality = self.personalities.get("default")
+            self._save_personalities()
+            return True
+        return False
+
+    def list_personalities(self) -> list:
+        """列出所有个性"""
+        return [
+            {
+                "name": p.name,
+                "description": p.description,
+                "current": p == self.current_personality
+            }
+            for p in self.personalities.values()
+        ]
+
+    def build_system_prompt(self) -> str:
+        """构建当前个性的系统提示"""
+        if not self.current_personality:
+            return ""
+
+        p = self.current_personality
+        parts = [
+            f"# 身份: {p.identity}",
+            f"\n{p.system_prompt}"
+        ]
+
+        if p.examples:
+            parts.append("\n## 示例对话:")
+            for ex in p.examples:
+                parts.append(f"- {ex}")
+
+        return "\n".join(parts)
+
+
+# 全局实例
+_personality_manager = None
+
+def get_personality_manager() -> PersonalityManager:
+    global _personality_manager
+    if _personality_manager is None:
+        _personality_manager = PersonalityManager()
+    return _personality_manager
+
+
+def set_personality(name: str) -> bool:
+    """设置当前个性"""
+    return get_personality_manager().set_personality(name)
+
+
+def get_current_personality() -> Optional[Personality]:
+    """获取当前个性"""
+    return get_personality_manager().get_current()
+
+
+def list_personalities() -> list:
+    """列出所有个性"""
+    return get_personality_manager().list_personalities()

fr_cli-2.3.0/fr_cli/agent/skills.py

@@ -0,0 +1,226 @@
+"""
+Skills 系统 - 参考 Hermes Agent 实现
+技能是 AI 自我学习的核心机制
+"""
+
+import os
+import json
+import time
+from typing import Dict, List, Optional, Callable
+from dataclasses import dataclass, field
+
+
+@dataclass
+class Skill:
+    """技能"""
+    name: str
+    description: str
+    content: str
+    author: str = "system"
+    created_at: float = field(default_factory=time.time)
+    updated_at: float = field(default_factory=time.time)
+    usage_count: int = 0
+    success_count: int = 0
+    tags: List[str] = field(default_factory=list)
+    enabled: bool = True
+
+    def to_dict(self) -> Dict:
+        return {
+            "name": self.name,
+            "description": self.description,
+            "content": self.content,
+            "author": self.author,
+            "created_at": self.created_at,
+            "updated_at": self.updated_at,
+            "usage_count": self.usage_count,
+            "success_count": self.success_count,
+            "tags": self.tags,
+            "enabled": self.enabled
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict) -> 'Skill':
+        return cls(
+            name=data["name"],
+            description=data.get("description", ""),
+            content=data["content"],
+            author=data.get("author", "system"),
+            created_at=data.get("created_at", time.time()),
+            updated_at=data.get("updated_at", time.time()),
+            usage_count=data.get("usage_count", 0),
+            success_count=data.get("success_count", 0),
+            tags=data.get("tags", []),
+            enabled=data.get("enabled", True)
+        )
+
+
+class SkillManager:
+    """技能管理器"""
+
+    def __init__(self, skills_dir: str = None):
+        if skills_dir is None:
+            skills_dir = os.path.expanduser("~/.fr_cli/skills")
+        self.skills_dir = skills_dir
+        self.skills: Dict[str, Skill] = {}
+        self._load_skills()
+        self._ensure_dir()
+
+    def _ensure_dir(self):
+        """确保目录存在"""
+        os.makedirs(self.skills_dir, exist_ok=True)
+
+    def _load_skills(self):
+        """加载所有技能"""
+        if not os.path.exists(self.skills_dir):
+            return
+
+        for filename in os.listdir(self.skills_dir):
+            if filename.endswith('.json'):
+                skill_path = os.path.join(self.skills_dir, filename)
+                try:
+                    with open(skill_path, 'r', encoding='utf-8') as f:
+                        data = json.load(f)
+                        skill = Skill.from_dict(data)
+                        self.skills[skill.name] = skill
+                except Exception:
+                    pass
+
+    def _save_skill(self, skill: Skill):
+        """保存技能"""
+        self._ensure_dir()
+        filename = f"{skill.name}.json".replace("/", "_")
+        filepath = os.path.join(self.skills_dir, filename)
+        with open(filepath, 'w', encoding='utf-8') as f:
+            json.dump(skill.to_dict(), f, ensure_ascii=False, indent=2)
+
+    def create_skill(self, name: str, description: str, content: str,
+                     author: str = "user", tags: List[str] = None) -> Skill:
+        """创建技能"""
+        skill = Skill(
+            name=name,
+            description=description,
+            content=content,
+            author=author,
+            tags=tags or []
+        )
+        self.skills[name] = skill
+        self._save_skill(skill)
+        return skill
+
+    def get_skill(self, name: str) -> Optional[Skill]:
+        """获取技能"""
+        return self.skills.get(name)
+
+    def update_skill(self, name: str, **kwargs):
+        """更新技能"""
+        if name in self.skills:
+            skill = self.skills[name]
+            for key, value in kwargs.items():
+                if hasattr(skill, key):
+                    setattr(skill, key, value)
+            skill.updated_at = time.time()
+            self._save_skill(skill)
+            return skill
+        return None
+
+    def delete_skill(self, name: str) -> bool:
+        """删除技能"""
+        if name in self.skills:
+            del self.skills[name]
+            filename = f"{name}.json".replace("/", "_")
+            filepath = os.path.join(self.skills_dir, filename)
+            if os.path.exists(filepath):
+                os.remove(filepath)
+            return True
+        return False
+
+    def list_skills(self, enabled_only: bool = True) -> List[Skill]:
+        """列出技能"""
+        skills = list(self.skills.values())
+        if enabled_only:
+            skills = [s for s in skills if s.enabled]
+        return skills
+
+    def search_skills(self, query: str) -> List[Skill]:
+        """搜索技能"""
+        query_lower = query.lower()
+        results = []
+        for skill in self.skills.values():
+            if (query_lower in skill.name.lower() or
+                query_lower in skill.description.lower() or
+                any(query_lower in tag.lower() for tag in skill.tags)):
+                results.append(skill)
+        return results
+
+    def record_usage(self, name: str, success: bool = True):
+        """记录技能使用"""
+        if name in self.skills:
+            skill = self.skills[name]
+            skill.usage_count += 1
+            if success:
+                skill.success_count += 1
+            self._save_skill(skill)
+
+    def build_system_prompt(self) -> str:
+        """构建技能系统提示"""
+        skills = self.list_skills()
+        if not skills:
+            return ""
+
+        lines = ["\n\n# 可用技能"]
+        for skill in skills:
+            lines.append(f"\n## {skill.name}")
+            lines.append(f"描述: {skill.description}")
+            lines.append(f"内容:\n{skill.content}")
+
+        return "\n".join(lines)
+
+    def learn_from_task(self, task: str, result: str, context: str = ""):
+        """从任务中学习并创建技能"""
+        skill = Skill(
+            name=f"skill_{int(time.time())}",
+            description=f"从任务 '{task[:50]}...' 学习",
+            content=f"任务: {task}\n\n结果: {result}\n\n上下文: {context}",
+            author="auto"
+        )
+        self.skills[skill.name] = skill
+        self._save_skill(skill)
+        return skill
+
+    def get_stats(self) -> Dict:
+        """获取统计"""
+        skills = list(self.skills.values())
+        return {
+            "total": len(skills),
+            "enabled": sum(1 for s in skills if s.enabled),
+            "total_usage": sum(s.usage_count for s in skills),
+            "success_rate": (
+                sum(s.success_count for s in skills) /
+                max(1, sum(s.usage_count for s in skills))
+            )
+        }
+
+
+# 全局实例
+_skill_manager = None
+
+def get_skill_manager() -> SkillManager:
+    global _skill_manager
+    if _skill_manager is None:
+        _skill_manager = SkillManager()
+    return _skill_manager
+
+
+def create_skill(name: str, description: str, content: str) -> Skill:
+    """创建技能快捷方法"""
+    return get_skill_manager().create_skill(name, description, content)
+
+
+def list_skills() -> List[Skill]:
+    """列出所有技能"""
+    return get_skill_manager().list_skills()
+
+
+def search_skills(query: str) -> List[Skill]:
+    """搜索技能"""
+    return get_skill_manager().search_skills(query)

{fr_cli-2.2.9 → fr_cli-2.3.0/fr_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fr-cli
-Version: 2.2.9
+Version: 2.3.0
 Summary: 凡人打字机 - 支持多模型(Zhipu/DeepSeek/Kimi/Qwen/StepFun/MiniMax/Spark/Doubao/MiMo)的终极全能终端工具
 Author: FANREN CLI Author
 License-Expression: MIT

{fr_cli-2.2.9 → fr_cli-2.3.0}/fr_cli.egg-info/SOURCES.txt

@@ -18,17 +18,21 @@ fr_cli/agent/a2a.py
 fr_cli/agent/acp.py
 fr_cli/agent/client.py
 fr_cli/agent/coding_helper.py
+fr_cli/agent/context_files.py
 fr_cli/agent/executor.py
+fr_cli/agent/gateway.py
 fr_cli/agent/generator.py
 fr_cli/agent/hermes.py
 fr_cli/agent/image_and_parallel.py
 fr_cli/agent/manager.py
 fr_cli/agent/master.py
 fr_cli/agent/master_prompt.py
+fr_cli/agent/personality.py
 fr_cli/agent/plugin_system.py
 fr_cli/agent/remote.py
 fr_cli/agent/server.py
 fr_cli/agent/shell_mode.py
+fr_cli/agent/skills.py
 fr_cli/agent/workflow.py
 fr_cli/agent/workflow_system.py
 fr_cli/agent/builtins/__init__.py

{fr_cli-2.2.9 → fr_cli-2.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fr-cli"
-version = "2.2.9"
+version = "2.3.0"
 description = "凡人打字机 - 支持多模型(Zhipu/DeepSeek/Kimi/Qwen/StepFun/MiniMax/Spark/Doubao/MiMo)的终极全能终端工具"
 readme = "README.md"
 requires-python = ">=3.8"