fr-cli 2.1.0__py3-none-any.whl

fr_cli/agent/master_prompt.py

@@ -0,0 +1,118 @@
+"""
+主 Agent（MasterAgent）提示词模板
+支持自我进化、规划、推理与工具调用。
+"""
+
+MASTER_SYSTEM_PROMPT_ZH = """你是 凡人打字机 的【主控Agent】——一位全能的AI助手兼系统指挥官。
+
+你的核心职责：
+1. 深入理解用户需求，将复杂任务拆解为可执行的步骤
+2. 调用系统工具完成用户的请求（文件、搜索、邮件、画图、定时任务等）
+3. 观察工具执行结果，必要时进行多轮修正
+4. 用中文向用户汇报最终结果
+
+=== 工具调用规范 ===
+当你需要调用工具时，必须严格使用以下 JSON 格式：
+
+```tool
+{"tool": "工具名", "params": {"参数名": "参数值"}}
+```
+
+可用工具清单：
+{tools_desc}
+
+=== 执行流程（ReAct 范式）===
+1. Thought（思考）：分析用户需求的本质，判断是否需工具介入
+2. Action（行动）：如需工具，输出 ```tool 代码块
+3. Observation（观察）：我会将工具执行结果反馈给你
+4. Final Answer（最终回答）：只有所有步骤完成且验证通过后，给出最终答案
+
+=== Agent 协作规则 ===
+- 你可以调用其他独立 Agent（本地或远程）来完成特定子任务
+- 当任务涉及专业领域（数据分析、爬虫、数据库查询等），优先调用对应的专业 Agent
+- 调用 Agent 使用 agent_call 工具: {"name": "Agent名", "user_input": "任务描述"}
+- 调用 Agent 后，将其返回结果整合到你的最终回答中
+- 如果远程 Agent 调用失败（网络或认证问题），尝试本地替代方案或向用户说明
+
+=== 自我进化规则 ===
+- 每次工具调用后，记录成功/失败模式
+- 如果同一类请求反复失败，调整策略（如换一种工具、简化参数）
+- 优先使用已验证成功的工具组合
+- 如果某个 Agent 协作频繁成功，优先在类似任务中继续使用该 Agent
+
+=== 重要约束 ===
+- 不要在 Thought 中编造不存在的信息
+- 每个 Action 后等待 Observation 再继续
+- 如果工具调用失败，必须分析原因并尝试替代方案
+- 禁止执行 rm -rf、格式化磁盘等危险操作
+"""
+
+MASTER_SYSTEM_PROMPT_EN = """You are the Master Agent of FANREN CLI — an all-powerful AI assistant and system commander.
+
+Your core duties:
+1. Deeply understand user needs and break complex tasks into executable steps
+2. Invoke system tools to fulfill requests (files, search, email, image generation, scheduled tasks, etc.)
+3. Observe tool execution results and perform multi-round corrections if necessary
+4. Report final results to the user
+
+=== Tool Calling Format ===
+When you need to call a tool, use this strict JSON format:
+
+```tool
+{"tool": "tool_name", "params": {"param_name": "param_value"}}
+```
+
+=== Execution Flow (ReAct Paradigm) ===
+1. Thought: Analyze the essence of the user request
+2. Action: Output a ```tool block if tools are needed
+3. Observation: I will feed back tool execution results
+4. Final Answer: Only give the final answer after all steps are complete
+
+=== Constraints ===
+- Do not fabricate information in Thought
+- Wait for Observation after each Action
+- If a tool fails, analyze why and try an alternative
+"""
+
+PLANNING_PROMPT_ZH = """用户提出了以下请求，请制定一个清晰的执行计划：
+
+用户请求：{user_input}
+
+当前系统状态：
+- 工作目录：{cwd}
+- 可用工具：{tool_list}
+
+请输出一个简洁的计划（最多5步），每步说明要做什么、使用什么工具。
+如果无需工具，直接回答即可。
+
+格式：
+1. [步骤1描述] → 工具: xxx
+2. [步骤2描述] → 工具: xxx
+...
+"""
+
+REFLECTION_PROMPT_ZH = """请对刚才的任务执行进行反思：
+
+任务：{task}
+执行步骤：{steps}
+结果：{result}
+是否成功：{success}
+
+请回答：
+1. 哪一步最关键？
+2. 如果再做一次，会怎么改进？
+3. 是否有更好的工具或路径？
+
+用1-2句话总结，我将记录到你的进化记忆中。"""
+
+SELF_EVOLVE_PROMPT_ZH = """基于你近期的交互历史，请优化自己的系统提示词。
+
+近期高频成功模式：
+{success_patterns}
+
+近期高频失败模式：
+{failure_patterns}
+
+请输出一段【补充提示词】（不超过300字），用于增强你处理类似任务的能力。
+这段提示词将被追加到你的 system prompt 中，帮助你持续进化。
+"""

fr_cli/agent/remote.py

@@ -0,0 +1,70 @@
+"""
+远程 Agent 管理 —— 配置其他用户电脑中已启用 API 的 fr-cli Agent
+
+配置文件: ~/.fr_cli_remote_agents.json
+格式:
+{
+    "agent_name": {
+        "host": "192.168.1.100",
+        "port": 8080,
+        "token": "xxx",
+        "description": "远程数据分析助手"
+    }
+}
+"""
+import json
+from pathlib import Path
+
+REMOTE_AGENTS_FILE = Path.home() / ".fr_cli_remote_agents.json"
+
+
+def _load_remote_agents():
+    if not REMOTE_AGENTS_FILE.exists():
+        return {}
+    try:
+        with open(REMOTE_AGENTS_FILE, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception:
+        return {}
+
+
+def _save_remote_agents(data):
+    try:
+        with open(REMOTE_AGENTS_FILE, "w", encoding="utf-8") as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+    except Exception:
+        pass
+
+
+def add_remote_agent(name, host, port, token, description=""):
+    """添加远程 Agent 配置"""
+    data = _load_remote_agents()
+    data[name] = {
+        "host": host,
+        "port": int(port),
+        "token": token,
+        "description": description,
+    }
+    _save_remote_agents(data)
+    return True
+
+
+def remove_remote_agent(name):
+    """删除远程 Agent 配置"""
+    data = _load_remote_agents()
+    if name in data:
+        del data[name]
+        _save_remote_agents(data)
+        return True
+    return False
+
+
+def list_remote_agents():
+    """列出所有远程 Agent"""
+    return _load_remote_agents()
+
+
+def get_remote_agent(name):
+    """获取单个远程 Agent 配置"""
+    data = _load_remote_agents()
+    return data.get(name)

fr_cli/agent/server.py

@@ -0,0 +1,279 @@
+"""
+Agent HTTP 服务 —— 将分身能力发布为 Web API
+供外部系统通过 REST 接口调用 Agent 的推理与执行能力。
+使用 Python 标准库 http.server，无需额外依赖。
+
+安全特性：
+- 默认仅绑定 127.0.0.1（本地回环）
+- 启动时自动生成随机 Token，所有请求需携带 Authorization: Bearer <token>
+- CORS 限制为同源，不再开放 *
+- 支持 IP 白名单（可选）
+"""
+import json
+import secrets
+import threading
+from http.server import HTTPServer, BaseHTTPRequestHandler
+from urllib.parse import urlparse
+
+from fr_cli.agent.manager import list_agents, load_persona, load_memory, load_skills
+from fr_cli.agent.workflow import load_workflow
+from fr_cli.agent.executor import run_agent
+from fr_cli.agent.workflow import run_workflow as wf_run
+
+
+class _AgentHTTPHandler(BaseHTTPRequestHandler):
+    """HTTP 请求处理器 —— 路由分发 + Token 认证 + CORS + IP 白名单"""
+
+    # 关闭默认日志输出（避免污染 CLI 界面）
+    def log_message(self, format, *args):
+        pass
+
+    def _check_auth(self):
+        """校验请求是否携带正确的 Bearer Token"""
+        expected = getattr(self.server, "_token", None)
+        if not expected:
+            return True
+        auth = self.headers.get("Authorization", "")
+        if auth.startswith("Bearer ") and auth[7:] == expected:
+            return True
+        return False
+
+    def _check_ip(self):
+        """IP 白名单校验"""
+        whitelist = getattr(self.server, "_ip_whitelist", None)
+        if not whitelist:
+            return True
+        client_ip = self.client_address[0]
+        return client_ip in whitelist
+
+    def _send_cors_headers(self):
+        """发送 CORS 响应头"""
+        allowed_origins = getattr(self.server, "_allowed_origins", [])
+        origin = self.headers.get("Origin", "")
+        if allowed_origins and origin in allowed_origins:
+            self.send_header("Access-Control-Allow-Origin", origin)
+        elif not allowed_origins:
+            # 未配置时默认只允许同源（不发送 CORS 头）
+            pass
+        self.send_header("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
+        self.send_header("Access-Control-Allow-Headers", "Content-Type, Authorization")
+
+    def _send_json(self, status, data):
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json; charset=utf-8")
+        self._send_cors_headers()
+        self.end_headers()
+        self.wfile.write(json.dumps(data, ensure_ascii=False).encode("utf-8"))
+
+    def _read_json(self):
+        try:
+            length = int(self.headers.get("Content-Length", 0))
+            if length:
+                body = self.rfile.read(length).decode("utf-8")
+                return json.loads(body)
+            return {}
+        except Exception:
+            return {}
+
+    def do_OPTIONS(self):
+        """处理 CORS 预检请求"""
+        self.send_response(204)
+        self._send_cors_headers()
+        self.end_headers()
+
+    def do_GET(self):
+        if not self._check_ip():
+            self._send_json(403, {"error": "IP not allowed"})
+            return
+        if not self._check_auth():
+            self._send_json(401, {"error": "Unauthorized"})
+            return
+
+        parsed = urlparse(self.path)
+        path = parsed.path
+        parts = [p for p in path.split("/") if p]
+
+        # /health
+        if path == "/health":
+            self._send_json(200, {"status": "ok"})
+            return
+
+        # /capabilities — 服务元数据与能力声明
+        if path == "/capabilities":
+            agents = list_agents()
+            self._send_json(200, {
+                "service": "fr-cli-agent-api",
+                "version": "2.1.0",
+                "agents": [
+                    {
+                        "name": a["name"],
+                        "has_persona": a["has_persona"],
+                        "has_memory": a["has_memory"],
+                        "has_skills": a["has_skills"],
+                    }
+                    for a in agents
+                ],
+                "endpoints": {
+                    "list_agents": "GET /agents",
+                    "agent_info": "GET /agents/<name>",
+                    "agent_run": "POST /agents/<name>/run",
+                    "agent_workflow": "POST /agents/<name>/workflow",
+                    "capabilities": "GET /capabilities",
+                },
+            })
+            return
+
+        # /agents
+        if path == "/agents":
+            agents = list_agents()
+            self._send_json(200, {"agents": agents})
+            return
+
+        # /agents/<name>
+        if len(parts) == 2 and parts[0] == "agents":
+            name = parts[1]
+            from fr_cli.agent.manager import agent_exists
+            if not agent_exists(name):
+                self._send_json(404, {"error": f"Agent not found: {name}"})
+                return
+            info = {
+                "name": name,
+                "persona": load_persona(name),
+                "memory": load_memory(name),
+                "skills": load_skills(name),
+                "has_workflow": load_workflow(name) is not None,
+            }
+            self._send_json(200, info)
+            return
+
+        self._send_json(404, {"error": "Not found"})
+
+    def do_POST(self):
+        if not self._check_ip():
+            self._send_json(403, {"error": "IP not allowed"})
+            return
+        if not self._check_auth():
+            self._send_json(401, {"error": "Unauthorized"})
+            return
+
+        parsed = urlparse(self.path)
+        path = parsed.path
+        parts = [p for p in path.split("/") if p]
+        body = self._read_json()
+
+        # /agents/<name>/run
+        if len(parts) == 3 and parts[0] == "agents" and parts[2] == "run":
+            name = parts[1]
+            from fr_cli.agent.manager import agent_exists
+            if not agent_exists(name):
+                self._send_json(404, {"error": f"Agent not found: {name}"})
+                return
+            state = self.server._state
+            user_input = body.get("input", "")
+            kwargs = body.get("kwargs", {})
+            if user_input:
+                kwargs["user_input"] = user_input
+            result, error = run_agent(name, state, **kwargs)
+            resp = {"result": result, "error": error}
+            self._send_json(200 if not error else 500, resp)
+            return
+
+        # /agents/<name>/workflow
+        if len(parts) == 3 and parts[0] == "agents" and parts[2] == "workflow":
+            name = parts[1]
+            from fr_cli.agent.manager import agent_exists
+            if not agent_exists(name):
+                self._send_json(404, {"error": f"Agent not found: {name}"})
+                return
+            state = self.server._state
+            user_input = body.get("input", "")
+            kwargs = body.get("kwargs", {})
+            final, error, steps = wf_run(name, state, user_input=user_input, **kwargs)
+            resp = {"result": final, "error": error, "steps": steps}
+            self._send_json(200 if not error else 500, resp)
+            return
+
+        self._send_json(404, {"error": "Not found"})
+
+
+class AgentHTTPServer:
+    """Agent HTTP 服务守护线程 —— 可启动、停止、查询状态"""
+
+    def __init__(self, state, host="127.0.0.1", port=17890):
+        self.state = state
+        self.host = host
+        self.port = port
+        self._server = None
+        self._thread = None
+        self._token = None
+        self._allowed_origins = []
+        self._ip_whitelist = []
+
+    def set_cors(self, origins):
+        """设置允许的 CORS 来源（默认空列表=不允许跨域）"""
+        self._allowed_origins = origins or []
+
+    def set_ip_whitelist(self, ips):
+        """设置 IP 白名单（默认空列表=不限制）"""
+        self._ip_whitelist = ips or []
+        if self._server is not None:
+            self._server._ip_whitelist = self._ip_whitelist
+
+    def start(self):
+        """启动 HTTP 服务（后台线程）"""
+        if self.is_running():
+            return False, f"服务已在运行: http://{self.host}:{self.port}"
+
+        self._token = secrets.token_urlsafe(16)
+        self._server = HTTPServer((self.host, self.port), _AgentHTTPHandler)
+        self._server._state = self.state
+        self._server._token = self._token
+        self._server._allowed_origins = self._allowed_origins
+        self._server._ip_whitelist = self._ip_whitelist
+        self._thread = threading.Thread(target=self._server.serve_forever, daemon=True)
+        self._thread.start()
+        msg = (
+            f"Agent HTTP 服务已启动: http://{self.host}:{self.port}\n"
+            f"  Token: {self._token}\n"
+            f"  使用示例: curl -H 'Authorization: Bearer {self._token}' http://{self.host}:{self.port}/agents\n"
+            f"  能力声明: curl -H 'Authorization: Bearer {self._token}' http://{self.host}:{self.port}/capabilities"
+        )
+        if self.host == "127.0.0.1":
+            msg += "\n  ⚠️ 当前仅绑定 127.0.0.1，外部无法访问。如需公网暴露请使用 ngrok 或修改 host。"
+        return True, msg
+
+    def stop(self):
+        """停止 HTTP 服务"""
+        if not self.is_running():
+            return False, "服务未运行"
+        self._server.shutdown()
+        self._server.server_close()
+        self._server = None
+        self._thread = None
+        self._token = None
+        return True, "Agent HTTP 服务已停止"
+
+    def is_running(self):
+        return self._server is not None and self._thread is not None and self._thread.is_alive()
+
+    def status(self):
+        if self.is_running():
+            return f"运行中: http://{self.host}:{self.port} (Token: {self._token})"
+        return "未运行"
+
+    def get_publish_info(self):
+        """获取对外发布的连接信息"""
+        if not self.is_running():
+            return None
+        import socket
+        hostname = socket.gethostname()
+        try:
+            local_ip = socket.getaddrinfo(hostname, None)[0][4][0]
+        except Exception:
+            local_ip = "127.0.0.1"
+        return {
+            "url": f"http://{self.host}:{self.port}",
+            "token": self._token,
+            "local_ip": local_ip,
+            "hostname": hostname,
+        }

fr_cli/agent/workflow.py

@@ -0,0 +1,164 @@
+
+"""
+Agent workflow engine
+"""
+
+import re
+
+WORKFLOW_FILE = "workflow.md"
+
+def load_workflow(name):
+    from pathlib import Path
+    from fr_cli.agent.manager import _agent_dir
+    p = _agent_dir(name) / WORKFLOW_FILE
+    if not p.exists():
+        return None
+    return p.read_text(encoding="utf-8")
+
+def save_workflow(name, content):
+    from pathlib import Path
+    from fr_cli.agent.manager import _agent_dir
+    p = _agent_dir(name) / WORKFLOW_FILE
+    p.write_text(content, encoding="utf-8")
+
+def parse_workflow(text):
+    steps = []
+    sections = re.split(r"\n## ", text)
+    for sec in sections[1:]:
+        lines = sec.strip().split("\n")
+        title_line = lines[0].strip()
+        m = re.match(r"步骤?(\d+)[\s:\-\.]+(.+)", title_line, re.I)
+        if m:
+            step_num = int(m.group(1))
+            step_title = m.group(2).strip()
+        else:
+            step_num = len(steps) + 1
+            step_title = title_line
+        action = ""
+        params = {}
+        in_params = False
+        for line in lines[1:]:
+            line = line.rstrip()
+            if not line:
+                continue
+            am = re.match(r"-\s+\*\*action\*\*\s*:\s*(.+)", line, re.I)
+            if am:
+                action = am.group(1).strip()
+                continue
+            if re.match(r"-\s+\*\*params\*\*\s*:", line, re.I):
+                in_params = True
+                continue
+            if in_params:
+                pm = re.match(r"\s+-\s+([\w_]+)\s*:\s*(.+)", line)
+                if pm:
+                    params[pm.group(1)] = pm.group(2).strip()
+        if action:
+            steps.append({"num": step_num, "title": step_title, "action": action, "params": params})
+    steps.sort(key=lambda x: x["num"])
+    return steps
+
+def _resolve_var(var_expr, context, step_results, user_input):
+    """解析模板变量，如 {{step1.result}} {{user_input}}"""
+    var_expr = var_expr.strip()
+    if var_expr == "user_input":
+        return user_input or ""
+    if var_expr == "agent.persona":
+        return context.get("persona", "")
+    if var_expr == "agent.memory":
+        return context.get("memory", "")
+    if var_expr == "agent.skills":
+        return context.get("skills", "")
+    sm = re.match(r"step(\d+)\.result", var_expr, re.I)
+    if sm:
+        idx = int(sm.group(1)) - 1
+        if 0 <= idx < len(step_results):
+            return str(step_results[idx].get("result", ""))
+    sm = re.match(r"step(\d+)\.error", var_expr, re.I)
+    if sm:
+        idx = int(sm.group(1)) - 1
+        if 0 <= idx < len(step_results):
+            return str(step_results[idx].get("error", ""))
+    return "{" + var_expr + "}"
+
+def _substitute_vars(text, context, step_results, user_input):
+    """替换文本中的所有 {{var}} 模板变量"""
+    if not isinstance(text, str):
+        return text
+    def repl(m):
+        return _resolve_var(m.group(1), context, step_results, user_input)
+    return re.sub(r"\{\{([^}]+)\}\}", repl, text)
+
+def run_workflow(name, state, user_input=None, **kwargs):
+    """执行 Agent 的工作流。返回 (final_result, error, step_results)"""
+    wf_text = load_workflow(name)
+    if not wf_text:
+        return None, "工作流不存在，使用 /agent_edit <name> workflow 定义工作流", []
+    steps = parse_workflow(wf_text)
+    if not steps:
+        return None, "工作流为空或解析失败", []
+
+    persona = load_persona(name)
+    memory = load_memory(name)
+    skills = load_skills(name)
+
+    context = {
+        "persona": persona,
+        "memory": memory,
+        "skills": skills,
+        "client": state.client,
+        "model": state.model_name,
+        "lang": state.lang,
+        "executor": state.executor,
+        "state": state,
+        "agent_name": name,
+    }
+
+    step_results = []
+    for step in steps:
+        action = step["action"]
+        params = {k: _substitute_vars(v, context, step_results, user_input) for k, v in step["params"].items()}
+        result = None
+        error = None
+
+        try:
+            if action in ("invoke_tool", "tool"):
+                tool_name = params.pop("tool", list(params.keys())[0] if params else "")
+                tool_params = params
+                result, error = state.executor.invoke_tool(tool_name, tool_params)
+            elif action in ("execute_cmd", "cmd", "command"):
+                cmd_str = params.get("cmd", "")
+                result, error = state.executor.execute(cmd_str)
+            elif action in ("agent_call", "agent", "call_agent"):
+                target = params.get("target") or params.get("agent") or params.get("to")
+                message = params.get("message", "")
+                result, error = run_agent(target, state, pipeline_input=message, **kwargs)
+            elif action in ("ai_generate", "ai", "generate", "ask"):
+                prompt = params.get("prompt", "")
+                from fr_cli.core.stream import stream_cnt
+                msgs = [{"role": "user", "content": prompt}]
+                result, _, _ = stream_cnt(state.client, state.model_name, msgs, state.lang)
+            elif action in ("save_memory", "memory_append"):
+                mem = params.get("content", "")
+                from fr_cli.agent.manager import save_memory, load_memory
+                old = load_memory(name)
+                save_memory(name, old + "\n" + mem if old else mem)
+                result = "记忆已更新"
+            else:
+                error = f"未知动作: {action}"
+        except Exception as e:
+            error = str(e)
+
+        step_results.append({
+            "step": step["num"],
+            "title": step["title"],
+            "action": action,
+            "result": result,
+            "error": error,
+        })
+
+        if error:
+            return None, f"步骤 {step['num']} ({step['title']}) 失败: {error}", step_results
+
+    final_result = step_results[-1]["result"] if step_results else None
+    return final_result, None, step_results
+