fr-cli 2.1.0__py3-none-any.whl

fr_cli/core/thinking.py

@@ -0,0 +1,215 @@
+"""
+思维引擎 —— 造化推演
+支持 CoT（思维链）、ToT（思维树）、ReAct（推理+行动）三种思维模式。
+在最终回答前，让大模型按照人类思维范式进行问题拆解和自我反馈验证。
+"""
+
+COT_PROMPT_ZH = """你是一个深度思考专家。用户提出了以下问题，请严格按照以下步骤进行完整的思维推演：
+
+步骤1 — 问题拆解：将用户问题分解为若干个独立的子问题，明确每个子问题的核心诉求。
+步骤2 — 信息评估：列出已知信息、缺失信息、以及可能需要验证的假设。
+步骤3 — 路径探索：针对每个子问题，提出至少两种解决思路，并简要说明各自的优劣。
+步骤4 — 方案筛选：综合评估后，选择最优解决路径，并说明选择理由。
+步骤5 — 自我验证：以批判者视角审视你的推理链，检查是否存在逻辑漏洞、过度推断或遗漏的边界情况。
+步骤6 — 风险兜底：如果最优方案失败，备选方案是什么？
+
+要求：
+- 每个步骤必须独立成段，标题明确
+- 推理要具体、可执行，不要空洞的概括
+- 最后用一个简短的"结论摘要"总结核心思路
+
+用户问题：{question}
+
+请开始深度思考："""
+
+COT_PROMPT_EN = """You are a deep-thinking expert. The user has asked the following question. Please conduct a complete chain-of-thought reasoning strictly following these steps:
+
+Step 1 — Problem Decomposition: Break the user's question into independent sub-problems, clarifying the core need of each.
+Step 2 — Information Assessment: List known facts, missing information, and assumptions that need verification.
+Step 3 — Path Exploration: For each sub-problem, propose at least two solution approaches with brief pros/cons.
+Step 4 — Solution Selection: Choose the optimal path with justification.
+Step 5 — Self-Verification: Review your reasoning chain critically for logical gaps, over-inference, or overlooked edge cases.
+Step 6 — Risk Mitigation: If the optimal solution fails, what is the fallback plan?
+
+Requirements:
+- Each step must be a separate paragraph with a clear heading
+- Reasoning must be concrete and actionable, not vague summaries
+- End with a brief "Conclusion Summary"
+
+User Question: {question}
+
+Begin deep thinking:"""
+
+TOT_PROMPT_ZH = """你是一个战略思维专家。请使用思维树（Tree of Thought）方法对用户问题进行系统性分析。
+
+思维树构建规则：
+1. 【根节点】提炼问题的核心目标（用一句话概括）
+2. 【第一层分支】生成至少3个不同的解决策略（标注为 策略A、策略B、策略C）
+3. 【第二层分支】对每个策略进行至少两层深入展开（子策略/具体步骤）
+4. 【节点评估】对每个叶子节点从以下维度评分（1-5分）：
+   - 可行性（技术/资源是否允许）
+   - 准确性（是否能真正解决问题）
+   - 效率（时间/成本开销）
+5. 【路径选择】选择总分最高的完整路径作为最优方案
+6. 【反向验证】假设最优路径因某个节点失败而中断，从该节点的父节点出发，选择次优分支作为备选
+7. 【收敛总结】用一句话总结最终推荐的行动方案
+
+要求：
+- 以树状层级格式输出（使用缩进或 ├── 符号）
+- 评分必须给出具体理由，不能只有数字
+- 最后明确标注"推荐方案"和"备选方案"
+
+用户问题：{question}
+
+请构建思维树："""
+
+TOT_PROMPT_EN = """You are a strategic thinking expert. Please conduct a systematic analysis of the user's question using the Tree of Thought methodology.
+
+Tree Construction Rules:
+1. [Root Node] Distill the core objective in one sentence
+2. [Level-1 Branches] Generate at least 3 distinct strategies (labeled Strategy A, B, C)
+3. [Level-2 Branches] Expand each strategy at least two levels deep (sub-strategies / concrete steps)
+4. [Node Evaluation] Score each leaf node on (1-5):
+   - Feasibility (technical/resource constraints)
+   - Accuracy (does it truly solve the problem)
+   - Efficiency (time/cost overhead)
+5. [Path Selection] Choose the highest-scoring complete path as optimal
+6. [Backtracking] If the optimal path fails at any node, select the next-best branch from the parent node as fallback
+7. [Convergence] Summarize the final recommended action in one sentence
+
+Requirements:
+- Output in tree hierarchy format (use indentation or ├── symbols)
+- Scores must include rationale, not just numbers
+- Clearly label "Recommended Plan" and "Fallback Plan"
+
+User Question: {question}
+
+Construct the thought tree:"""
+
+REACT_SYSTEM_ENHANCEMENT_ZH = """
+
+---
+【ReAct 推演模式已激活】
+在回答用户问题时，请严格遵循 ReAct（Reasoning + Acting）范式：
+
+1. Thought（观察与思考）：
+   - 先观察用户问题的核心诉求
+   - 明确当前已掌握的信息和缺失的信息
+   - 思考下一步应该采取什么行动来获取信息或解决问题
+   - 每轮思考后进行自我检查："我的推理是否存在漏洞？"
+
+2. Action（行动）：
+   - 如果需要调用工具，使用标准格式：【调用：tool_name({"参数": "值"})】
+   - 如果信息足够，直接给出答案
+   - 如果信息不足，明确说明需要什么额外信息
+
+3. Observation（观察结果）：
+   - 工具执行结果会自动反馈给你
+   - 基于新信息更新你的思考
+
+4. Final Answer（最终答案）：
+   - 只有当所有子问题都解决、所有验证都通过后，才给出最终答案
+   - 最终答案前必须包含一行："✅ 验证通过，以下是最终结论："
+
+重要：
+- 不要在 Thought 中编造不存在的信息
+- 每个 Action 后等待 Observation 再继续
+- 如果某个路径失败，必须回溯并尝试替代方案
+"""
+
+REACT_SYSTEM_ENHANCEMENT_EN = """
+
+---
+[ReAct Mode Activated]
+When answering the user's question, strictly follow the ReAct (Reasoning + Acting) paradigm:
+
+1. Thought (Observation & Reasoning):
+   - Observe the core intent of the user's question
+   - Identify what information is known and what is missing
+   - Decide the next action to acquire information or solve the problem
+   - After each round of reasoning, self-check: "Does my reasoning have any flaws?"
+
+2. Action:
+   - If a tool is needed, use the standard format: 【调用：tool_name({"param": "value"})】
+   - If information is sufficient, provide the answer directly
+   - If information is insufficient, clearly state what additional info is needed
+
+3. Observation:
+   - Tool execution results will be fed back to you automatically
+   - Update your reasoning based on new information
+
+4. Final Answer:
+   - Only provide the final answer after all sub-problems are resolved and all checks pass
+   - Must include a line before the final answer: "✅ Verification passed. Final conclusion:"
+
+Important:
+- Do not fabricate information in Thought
+- Wait for Observation after each Action
+- If a path fails, backtrack and try an alternative
+"""
+
+
+class ThinkingEngine:
+    """思维引擎 —— 支持 CoT / ToT / ReAct / direct 四种模式"""
+
+    MODES = ["direct", "cot", "tot", "react"]
+
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def is_valid_mode(mode):
+        return mode in ThinkingEngine.MODES
+
+    def analyze(self, state, user_input, mode, intent, lang="zh"):
+        """
+        根据思维模式对用户问题进行预处理分析。
+
+        Returns:
+            reasoning_text (str or None): 对于 cot/tot，返回思维推演文本；
+                                          对于 react，返回 system prompt 增强片段；
+                                          对于 direct，返回 None。
+        """
+        if mode == "direct" or mode not in self.MODES:
+            return None
+
+        if mode == "cot":
+            return self._run_cot(state, user_input, lang)
+        elif mode == "tot":
+            return self._run_tot(state, user_input, lang)
+        elif mode == "react":
+            return self._get_react_enhancement(lang)
+
+    def _run_cot(self, state, user_input, lang):
+        """执行思维链推演（额外一次 LLM 调用）"""
+        from fr_cli.core.stream import stream_cnt
+
+        prompt_template = COT_PROMPT_ZH if lang == "zh" else COT_PROMPT_EN
+        prompt = prompt_template.format(question=user_input)
+        messages = [{"role": "user", "content": prompt}]
+
+        txt, _, _ = stream_cnt(
+            state.client, state.model_name, messages, lang,
+            custom_prefix="", max_tokens=2048, silent=True
+        )
+        return txt.strip() if txt else None
+
+    def _run_tot(self, state, user_input, lang):
+        """执行思维树推演（额外一次 LLM 调用）"""
+        from fr_cli.core.stream import stream_cnt
+
+        prompt_template = TOT_PROMPT_ZH if lang == "zh" else TOT_PROMPT_EN
+        prompt = prompt_template.format(question=user_input)
+        messages = [{"role": "user", "content": prompt}]
+
+        txt, _, _ = stream_cnt(
+            state.client, state.model_name, messages, lang,
+            custom_prefix="", max_tokens=2048, silent=True
+        )
+        return txt.strip() if txt else None
+
+    def _get_react_enhancement(self, lang):
+        """获取 ReAct system prompt 增强片段（不额外调用 LLM）"""
+        if lang == "zh":
+            return REACT_SYSTEM_ENHANCEMENT_ZH
+        return REACT_SYSTEM_ENHANCEMENT_EN

fr_cli/gatekeeper/__init__.py

@@ -0,0 +1,7 @@
+"""
+Gatekeeper 守护进程系统 —— 后台结界主宰
+负责在主进程退出后继续维持定时任务与 Agent HTTP 等核心服务运转。
+"""
+from fr_cli.gatekeeper.manager import GatekeeperManager, get_manager
+
+__all__ = ["GatekeeperManager", "get_manager"]

fr_cli/gatekeeper/daemon.py

@@ -0,0 +1,216 @@
+"""
+Gatekeeper 守护进程 —— 后台结界主宰
+负责在主进程退出后继续维持核心服务运转。
+支持：Agent HTTP 服务、全局定时任务（shell/agent）、配置热重载。
+
+启动方式（不应由用户直接调用）：
+    python -m fr_cli.gatekeeper.daemon
+
+停止方式：
+    创建 ~/.fr_cli_gatekeeper.stop 标记文件，守护进程检测到后自行退出。
+"""
+import os
+import sys
+import time
+import json
+import signal
+import atexit
+from pathlib import Path
+
+# 确保项目根目录在 Python 路径中
+_project_root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+if _project_root not in sys.path:
+    sys.path.insert(0, _project_root)
+
+PID_FILE = Path.home() / ".fr_cli_gatekeeper.pid"
+STOP_FILE = Path.home() / ".fr_cli_gatekeeper.stop"
+DAEMON_CONFIG_FILE = Path.home() / ".fr_cli_gatekeeper.json"
+
+# 配置热重载间隔（秒）
+RELOAD_INTERVAL = 30
+
+
+def _write_pid(pid):
+    try:
+        with open(PID_FILE, "w", encoding="utf-8") as f:
+            f.write(str(pid))
+    except Exception:
+        pass
+
+
+def _clear_stop_marker():
+    if STOP_FILE.exists():
+        try:
+            STOP_FILE.unlink()
+        except Exception:
+            pass
+
+
+def _cleanup():
+    _clear_stop_marker()
+    if PID_FILE.exists():
+        try:
+            PID_FILE.unlink()
+        except Exception:
+            pass
+
+
+def _setup_signal_handlers():
+    def _sigterm_handler(signum, frame):
+        _cleanup()
+        sys.exit(0)
+
+    signal.signal(signal.SIGTERM, _sigterm_handler)
+    if hasattr(signal, "SIGINT"):
+        signal.signal(signal.SIGINT, _sigterm_handler)
+
+
+def _load_daemon_config():
+    if DAEMON_CONFIG_FILE.exists():
+        try:
+            with open(DAEMON_CONFIG_FILE, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except Exception:
+            pass
+    return {}
+
+
+def _reload_cron_jobs(cron_mgr, daemon_cfg, state):
+    """热重载定时任务配置：对比当前运行任务与配置文件，增删同步。"""
+    cfg_jobs = daemon_cfg.get("cron_jobs", [])
+    # 过滤出 shell 类型的全局定时任务
+    shell_jobs = [j for j in cfg_jobs if j.get("job_type", "shell") == "shell"]
+    cron_mgr.sync_jobs(shell_jobs, lang=daemon_cfg.get("lang", "zh"))
+
+
+def _reload_agent_crons(cron_mgr, daemon_cfg, state):
+    """热重载 Agent 分身定时任务：对比当前运行任务与配置文件，增删同步。"""
+    import copy
+    cfg_jobs = daemon_cfg.get("agent_crons", [])
+    # 深拷贝避免修改原始配置 dict，防止无限重载循环
+    cfg_jobs = copy.deepcopy(cfg_jobs)
+    for j in cfg_jobs:
+        j["job_type"] = "agent"
+    cron_mgr.sync_jobs(cfg_jobs, lang=daemon_cfg.get("lang", "zh"), state=state)
+
+
+def _init_services(daemon_cfg):
+    """初始化并启动核心子系统"""
+    from fr_cli.conf.config import load_config
+    from fr_cli.core.core import AppState
+    from fr_cli.agent.server import AgentHTTPServer
+    from fr_cli.weapon.cron import CronManager
+
+    # 加载用户主配置（不触发交互式向导）
+    cfg = load_config()
+    state = AppState(cfg)
+
+    services = {
+        "state": state,
+        "agent_server": None,
+        "cron_manager": None,
+    }
+
+    # 启动 Agent HTTP 服务
+    agent_port = daemon_cfg.get("agent_server_port")
+    if agent_port:
+        try:
+            agent_port = int(agent_port)
+            agent_server = AgentHTTPServer(state, port=agent_port)
+            ok, msg = agent_server.start()
+            if ok:
+                services["agent_server"] = agent_server
+        except Exception:
+            pass
+
+    # 初始化 CronManager 并恢复所有定时任务
+    cron_mgr = CronManager()
+
+    # 恢复 shell 类型全局定时任务
+    cron_jobs = daemon_cfg.get("cron_jobs", [])
+    for job in cron_jobs:
+        try:
+            jtype = job.get("job_type", "shell")
+            if jtype == "shell":
+                cron_mgr.add_job(
+                    cmd=job["cmd"],
+                    interval=job["interval"],
+                    lang=job.get("lang", "zh"),
+                    job_type="shell",
+                )
+        except Exception:
+            pass
+
+    # 恢复 Agent 分身定时任务（需要 AppState）
+    agent_crons = daemon_cfg.get("agent_crons", [])
+    for job in agent_crons:
+        try:
+            cron_mgr.add_job(
+                cmd=job.get("cmd", job.get("agent_name", "")),
+                interval=job["interval"],
+                lang=job.get("lang", "zh"),
+                job_type="agent",
+                agent_name=job.get("agent_name"),
+                agent_input=job.get("agent_input", ""),
+                state=state,
+            )
+        except Exception:
+            pass
+
+    services["cron_manager"] = cron_mgr
+    return services
+
+
+def run_daemon():
+    """守护进程主循环"""
+    _clear_stop_marker()
+    _write_pid(os.getpid())
+    atexit.register(_cleanup)
+    _setup_signal_handlers()
+
+    daemon_cfg = _load_daemon_config()
+    services = _init_services(daemon_cfg)
+    cron_mgr = services["cron_manager"]
+    state = services["state"]
+
+    last_reload = time.time()
+
+    # 主循环：定期检查停止标记 + 热重载配置
+    while True:
+        time.sleep(2)
+
+        if STOP_FILE.exists():
+            break
+
+        # 每 RELOAD_INTERVAL 秒热重载一次配置
+        if time.time() - last_reload >= RELOAD_INTERVAL:
+            last_reload = time.time()
+            new_cfg = _load_daemon_config()
+            if new_cfg != daemon_cfg:
+                daemon_cfg = new_cfg
+                _reload_cron_jobs(cron_mgr, daemon_cfg, state)
+                _reload_agent_crons(cron_mgr, daemon_cfg, state)
+
+    # 停止所有子服务
+    agent_server = services.get("agent_server")
+    if agent_server and getattr(agent_server, "is_running", lambda: False)():
+        try:
+            agent_server.stop()
+        except Exception:
+            pass
+
+    # 取消所有定时任务
+    cron_mgr = services.get("cron_manager")
+    if cron_mgr:
+        for job in list(cron_mgr.jobs):
+            if job.get("timer"):
+                try:
+                    job["timer"].cancel()
+                except Exception:
+                    pass
+
+    _cleanup()
+
+
+if __name__ == "__main__":
+    run_daemon()

fr_cli/gatekeeper/manager.py

@@ -0,0 +1,218 @@
+"""
+Gatekeeper 管理器 —— 结界主宰
+在主进程中控制守护进程的启动、停止与状态查询。
+"""
+import os
+import sys
+import time
+import json
+import signal
+import subprocess
+from pathlib import Path
+
+PID_FILE = Path.home() / ".fr_cli_gatekeeper.pid"
+STOP_FILE = Path.home() / ".fr_cli_gatekeeper.stop"
+DAEMON_CONFIG_FILE = Path.home() / ".fr_cli_gatekeeper.json"
+
+
+class GatekeeperManager:
+    """守护进程管理器"""
+
+    def __init__(self):
+        pass
+
+    @staticmethod
+    def _daemon_script_path():
+        return Path(__file__).with_name("daemon.py")
+
+    @staticmethod
+    def _read_pid():
+        if PID_FILE.exists():
+            try:
+                return int(PID_FILE.read_text(encoding="utf-8").strip())
+            except Exception:
+                pass
+        return None
+
+    @staticmethod
+    def _is_pid_alive(pid):
+        """跨平台检测进程是否存活"""
+        try:
+            if sys.platform == "win32":
+                import ctypes
+                kernel32 = ctypes.windll.kernel32
+                handle = kernel32.OpenProcess(1, False, pid)
+                if handle:
+                    kernel32.CloseHandle(handle)
+                    return True
+                return False
+            else:
+                os.kill(pid, 0)
+                return True
+        except (OSError, ProcessLookupError):
+            return False
+
+    @staticmethod
+    def _cleanup_files():
+        for f in (PID_FILE, STOP_FILE):
+            if f.exists():
+                try:
+                    f.unlink()
+                except Exception:
+                    pass
+
+    @staticmethod
+    def save_daemon_config(cfg):
+        """保存守护进程配置供下次启动使用"""
+        try:
+            with open(DAEMON_CONFIG_FILE, "w", encoding="utf-8") as f:
+                json.dump(cfg, f, ensure_ascii=False, indent=2)
+        except Exception as e:
+            return False, str(e)
+        return True, "配置已保存"
+
+    def is_running(self):
+        pid = self._read_pid()
+        if pid and self._is_pid_alive(pid):
+            return True
+        # 残留文件清理
+        if PID_FILE.exists():
+            self._cleanup_files()
+        return False
+
+    def start(self):
+        """启动守护进程"""
+        if self.is_running():
+            pid = self._read_pid()
+            return False, f"Gatekeeper 守护进程已在运行 (PID: {pid})"
+
+        self._cleanup_files()
+        daemon_script = self._daemon_script_path()
+        if not daemon_script.exists():
+            return False, f"守护进程脚本不存在: {daemon_script}"
+
+        try:
+            kwargs = {}
+            if sys.platform == "win32":
+                kwargs["creationflags"] = subprocess.CREATE_NEW_PROCESS_GROUP
+
+            proc = subprocess.Popen(
+                [sys.executable, str(daemon_script)],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                stdin=subprocess.DEVNULL,
+                close_fds=True,
+                **kwargs
+            )
+
+            # 等待 PID 文件写入
+            for _ in range(10):
+                time.sleep(0.3)
+                pid = self._read_pid()
+                if pid and self._is_pid_alive(pid):
+                    return True, f"Gatekeeper 守护进程已启动 (PID: {pid})"
+                if proc.poll() is not None:
+                    return False, "守护进程启动后立即退出，请检查配置。"
+
+            return True, f"Gatekeeper 守护进程已启动 (PID: {proc.pid})"
+        except Exception as e:
+            return False, f"启动失败: {e}"
+
+    def stop(self):
+        """停止守护进程"""
+        pid = self._read_pid()
+        if not pid:
+            self._cleanup_files()
+            return False, "Gatekeeper 守护进程未运行。"
+
+        if not self._is_pid_alive(pid):
+            self._cleanup_files()
+            return False, "Gatekeeper 守护进程未运行（已清理残留状态）。"
+
+        # 写入停止标记
+        try:
+            STOP_FILE.write_text("1", encoding="utf-8")
+        except Exception as e:
+            return False, f"发送停止信号失败: {e}"
+
+        # 等待进程自行退出
+        for _ in range(15):
+            if not self._is_pid_alive(pid):
+                self._cleanup_files()
+                return True, "Gatekeeper 守护进程已停止。"
+            time.sleep(0.5)
+
+        # 强制终止
+        try:
+            if sys.platform == "win32":
+                os.kill(pid, signal.CTRL_BREAK_EVENT)
+            else:
+                os.kill(pid, signal.SIGTERM)
+        except ProcessLookupError:
+            pass
+        except Exception:
+            pass
+
+        # 再等待一次
+        for _ in range(5):
+            if not self._is_pid_alive(pid):
+                self._cleanup_files()
+                return True, "Gatekeeper 守护进程已停止。"
+            time.sleep(0.5)
+
+        self._cleanup_files()
+        return True, "Gatekeeper 守护进程已强制停止。"
+
+    def status(self):
+        """查询守护进程状态"""
+        pid = self._read_pid()
+        if not pid:
+            return "Gatekeeper 守护进程未运行。"
+        if self._is_pid_alive(pid):
+            return f"Gatekeeper 守护进程运行中 (PID: {pid})"
+        self._cleanup_files()
+        return "Gatekeeper 守护进程未运行（已清理残留状态）。"
+
+
+def get_manager():
+    return GatekeeperManager()
+
+
+def read_daemon_config():
+    """读取当前守护进程配置"""
+    if DAEMON_CONFIG_FILE.exists():
+        try:
+            with open(DAEMON_CONFIG_FILE, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except Exception:
+            pass
+    return {}
+
+
+def sync_gatekeeper_cron_jobs(cron_jobs=None, agent_crons=None, append=False):
+    """同步定时任务配置到 gatekeeper 配置文件。
+
+    Args:
+        cron_jobs: shell 类型任务列表，每项为 dict
+        agent_crons: Agent 类型任务列表，每项为 dict
+        append: 是否追加模式（False 则替换对应字段）
+    """
+    cfg = read_daemon_config()
+    if cron_jobs is not None and not append:
+        cfg["cron_jobs"] = cron_jobs
+    elif cron_jobs is not None and append:
+        existing = cfg.get("cron_jobs", [])
+        cfg["cron_jobs"] = existing + [j for j in cron_jobs if j not in existing]
+
+    if agent_crons is not None and not append:
+        cfg["agent_crons"] = agent_crons
+    elif agent_crons is not None and append:
+        existing = cfg.get("agent_crons", [])
+        cfg["agent_crons"] = existing + [j for j in agent_crons if j not in existing]
+
+    try:
+        with open(DAEMON_CONFIG_FILE, "w", encoding="utf-8") as f:
+            json.dump(cfg, f, ensure_ascii=False, indent=2)
+        return True
+    except Exception:
+        return False