fr-cli 2.1.0__py3-none-any.whl

fr_cli/agent/client.py

@@ -0,0 +1,164 @@
+"""
+Agent API 客户端 —— 支持本地调用和远程 HTTP API 调用
+MasterAgent 通过此模块调用其他独立 Agent（本地或远程）
+"""
+import json
+import urllib.request
+import urllib.error
+
+from fr_cli.agent.executor import run_agent
+from fr_cli.agent.remote import list_remote_agents, get_remote_agent, add_remote_agent
+from fr_cli.agent.manager import list_agents as list_local_agents
+
+
+def discover_all_agents():
+    """
+    发现所有可用 Agent：本地 + 远程
+    返回列表: [{"name": str, "type": "local|remote", "description": str}]
+    """
+    results = []
+
+    # 本地 Agent
+    for a in list_local_agents():
+        results.append({
+            "name": a["name"],
+            "type": "local",
+            "description": f"本地Agent (persona:{a['has_persona']}, memory:{a['has_memory']}, skills:{a['has_skills']})",
+        })
+
+    # 远程 Agent
+    for name, cfg in list_remote_agents().items():
+        results.append({
+            "name": name,
+            "type": "remote",
+            "description": cfg.get("description", f"远程Agent @ {cfg['host']}:{cfg['port']}"),
+        })
+
+    return results
+
+
+def call_agent(name, state, user_input="", **kwargs):
+    """
+    统一入口：调用 Agent（自动判断本地或远程）
+    返回 (result, error)
+    """
+    # 优先检查本地 Agent
+    from fr_cli.agent.manager import agent_exists
+    if agent_exists(name):
+        return run_agent(name, state, user_input=user_input, **kwargs)
+
+    # 检查远程 Agent
+    remote_cfg = get_remote_agent(name)
+    if remote_cfg:
+        return call_remote_agent(name, user_input, remote_cfg)
+
+    return None, f"Agent [{name}] 未找到（本地和远程均无此Agent）"
+
+
+def call_remote_agent(name, user_input, cfg):
+    """
+    通过 HTTP API 调用远程 Agent
+    cfg: {"host": str, "port": int, "token": str}
+    返回 (result, error)
+    """
+    host = cfg.get("host", "127.0.0.1")
+    port = cfg.get("port", 17890)
+    token = cfg.get("token", "")
+
+    url = f"http://{host}:{port}/agents/{name}/run"
+    payload = json.dumps({"input": user_input, "kwargs": {}}).encode("utf-8")
+
+    req = urllib.request.Request(
+        url,
+        data=payload,
+        headers={
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {token}",
+        },
+        method="POST",
+    )
+
+    try:
+        with urllib.request.urlopen(req, timeout=30) as resp:
+            data = json.loads(resp.read().decode("utf-8"))
+            if data.get("error"):
+                return None, f"远程Agent错误: {data['error']}"
+            return data.get("result", ""), None
+    except urllib.error.HTTPError as e:
+        err_body = e.read().decode("utf-8") if hasattr(e, "read") else str(e)
+        return None, f"远程Agent HTTP {e.code}: {err_body}"
+    except urllib.error.URLError as e:
+        return None, f"远程Agent连接失败: {e.reason}"
+    except Exception as e:
+        return None, f"远程Agent调用异常: {e}"
+
+
+def scan_remote_host(host, port, token):
+    """
+    扫描远程主机，获取其提供的 Agent 列表和服务能力
+    返回 ({"service": ..., "agents": [...]}, error)
+    """
+    # 1. 获取能力声明
+    cap_url = f"http://{host}:{port}/capabilities"
+    req = urllib.request.Request(
+        cap_url,
+        headers={"Authorization": f"Bearer {token}"},
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            caps = json.loads(resp.read().decode("utf-8"))
+    except Exception as e:
+        return None, f"无法获取远程能力声明: {e}"
+
+    # 2. 获取 Agent 列表
+    agents_url = f"http://{host}:{port}/agents"
+    req = urllib.request.Request(
+        agents_url,
+        headers={"Authorization": f"Bearer {token}"},
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            agents_data = json.loads(resp.read().decode("utf-8"))
+    except Exception as e:
+        return None, f"无法获取远程Agent列表: {e}"
+
+    return {
+        "service": caps.get("service", "unknown"),
+        "version": caps.get("version", "unknown"),
+        "agents": agents_data.get("agents", []),
+        "endpoints": caps.get("endpoints", {}),
+        "host": host,
+        "port": port,
+        "token": token,
+    }, None
+
+
+def import_remote_agents(host, port, token, prefix=""):
+    """
+    一键导入远程主机的所有 Agent 到本地配置
+    prefix: 可选前缀，避免与本地Agent重名
+    返回 (imported_count, errors)
+    """
+    info, err = scan_remote_host(host, port, token)
+    if err:
+        return 0, [err]
+
+    imported = 0
+    errors = []
+    for agent in info.get("agents", []):
+        name = agent["name"]
+        if prefix:
+            name = f"{prefix}_{name}"
+        try:
+            add_remote_agent(
+                name,
+                host,
+                port,
+                token,
+                description=f"远程Agent [{agent['name']}] @ {host}:{port}",
+            )
+            imported += 1
+        except Exception as e:
+            errors.append(f"导入 {name} 失败: {e}")
+
+    return imported, errors

fr_cli/agent/executor.py

@@ -0,0 +1,86 @@
+# Agent executor
+from fr_cli.agent.manager import (load_persona, load_memory, load_skills, load_agent_module, agent_exists, load_progress)
+from fr_cli.agent.workflow import run_workflow, load_workflow
+
+
+def run_agent(name, state, **kwargs):
+    if not agent_exists(name):
+        return None, "Agent not found. Use /agent_create <name> <description>"
+    if load_workflow(name):
+        result, err, _ = run_workflow(name, state, user_input=kwargs.get("pipeline_input"), **kwargs)
+        return result, err
+    persona = load_persona(name)
+    memory = load_memory(name)
+    skills = load_skills(name)
+    mod = load_agent_module(name)
+    if mod is None:
+        return None, "agent.py not found or load failed"
+    if not hasattr(mod, "run"):
+        return None, "agent.py missing run(context, **kwargs)"
+    progress = load_progress(name)
+    latest = progress.get("latest", {})
+    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,
+        "progress": progress,
+        "latest_result": latest.get("result", ""),
+        "latest_status": latest.get("status", ""),
+        "execution_count": progress.get("counter", 0),
+    }
+    try:
+        result = mod.run(context, **kwargs)
+        return result, None
+    except Exception as e:
+        return None, str(e)
+
+
+def delegate_to_agent(name, state, pipeline_input=None, **kwargs):
+    """将请求委托给指定 Agent 执行，支持管道输入（pipeline_input）供多 Agent 协作链使用。"""
+    if not agent_exists(name):
+        return None, f"Agent not found: {name}"
+    persona = load_persona(name)
+    memory = load_memory(name)
+    skills = load_skills(name)
+    mod = load_agent_module(name)
+    if mod is None:
+        return None, "agent.py not found or load failed"
+    if not hasattr(mod, "run"):
+        return None, "agent.py missing run(context, **kwargs)"
+    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,
+        "pipeline_input": pipeline_input,
+    }
+    try:
+        result = mod.run(context, **kwargs)
+        return result, None
+    except Exception as e:
+        return None, str(e)
+
+
+def run_multi_agent(names, state, initial_input=None, **kwargs):
+    """多 Agent 流水线协作 —— 将多个 Agent 串联执行，前一个的输出作为后一个的输入。"""
+    pipeline_result = initial_input
+    logs = []
+    for idx, name in enumerate(names, start=1):
+        print(f"[流水线] {idx}/{len(names)}: 运行 Agent {name}")
+        result, err = delegate_to_agent(name, state, pipeline_input=pipeline_result, **kwargs)
+        if err:
+            return None, f"Pipeline step {idx} ('{name}'): {err}"
+        logs.append({"agent": name, "result": result})
+        pipeline_result = result
+    return logs, None

fr_cli/agent/generator.py

@@ -0,0 +1,104 @@
+"""
+Agent 生成器 —— 分身铸造炉
+利用大模型能力，根据用户需求自动生成完整的 Agent（人设、技能、代码）
+"""
+import sys
+from fr_cli.core.stream import stream_cnt
+
+
+GENERATION_PROMPT_ZH = """你是 Agent 架构师。请根据以下需求，为一个新的 AI Agent 分身设计完整的设定和代码。
+
+Agent 名称: {name}
+需求描述: {description}
+
+请严格按照以下格式输出（保持三个标记之间的顺序）：
+
+---PERSONA_START---
+（在这里写人设设定，用 Markdown 格式。包括：角色定位、性格特点、行为准则、语气风格）
+---PERSONA_END---
+
+---SKILLS_START---
+（在这里写可用技能，用 Markdown 格式。列出 Agent 可以使用的工具和能力，每项技能包含名称、描述和调用方式）
+---SKILLS_END---
+
+---CODE_START---
+```python
+（在这里写完整的 Python 代码）
+```
+---CODE_END---
+
+对 Python 代码的要求：
+1. 必须包含 `def run(context, **kwargs):` 作为唯一入口函数
+2. `context` 是一个字典，包含以下键：
+   - 'persona': str — 人设文本
+   - 'memory': str — 记忆文本
+   - 'skills': str — 技能文本
+   - 'client': ZhipuAI 实例
+   - 'model': str — 模型名称
+   - 'lang': str — 语言代码（'zh' 或 'en'）
+   - 'executor': CommandExecutor 实例（可使用 invoke_tool/execute 调用工具）
+   - 'state': AppState 实例（可访问 vfs、cfg 等子系统）
+3. `kwargs` 包含用户调用时传入的参数
+4. 函数返回 str 类型的执行结果
+5. 代码要健壮，有异常处理
+6. 使用中文注释
+7. 充分利用 context 中的资源完成用户需求
+8. 如果需要调用 AI，使用 context['client'].chat.completions.create()
+9. 如果需要操作文件，使用 context['state'].vfs
+10. 如果需要调用工具，使用 context['executor'].invoke_tool() 或 context['executor'].execute()
+
+请确保输出中包含完整的三个部分（PERSONA、SKILLS、CODE），缺一不可。
+"""
+
+
+def _extract_section(text: str, start_marker: str, end_marker: str) -> str:
+    """从 AI 回复中提取标记之间的内容"""
+    s = text.find(start_marker)
+    e = text.find(end_marker)
+    if s == -1 or e == -1 or e <= s:
+        return ""
+    return text[s + len(start_marker):e].strip()
+
+
+def _clean_code_block(code: str) -> str:
+    """去除代码块标记 ```python ... ```"""
+    code = code.strip()
+    if code.startswith("```python"):
+        code = code[len("```python"):].strip()
+    elif code.startswith("```"):
+        code = code[len("```"):].strip()
+    if code.endswith("```"):
+        code = code[:-3].strip()
+    return code
+
+
+def generate_agent(client, model, name: str, description: str, lang: str = "zh") -> dict:
+    """
+    调用大模型生成完整的 Agent。
+    返回 {"persona": str, "skills": str, "code": str, "raw": str}
+    """
+    prompt = GENERATION_PROMPT_ZH.format(name=name, description=description)
+    messages = [{"role": "user", "content": prompt}]
+
+    sys.stdout.write("🧙 正在铸造分身... ")
+    sys.stdout.flush()
+    raw, _, _ = stream_cnt(client, model, messages, lang, custom_prefix="", max_tokens=4096)
+
+    persona = _extract_section(raw, "---PERSONA_START---", "---PERSONA_END---")
+    skills = _extract_section(raw, "---SKILLS_START---", "---SKILLS_END---")
+    code = _extract_section(raw, "---CODE_START---", "---CODE_END---")
+    code = _clean_code_block(code)
+
+    # 如果没有提取到代码，尝试从原始回复中直接找代码块
+    if not code and "```python" in raw:
+        s = raw.find("```python")
+        e = raw.find("```", s + 1)
+        if e > s:
+            code = _clean_code_block(raw[s:e + 3])
+
+    return {
+        "persona": persona,
+        "skills": skills,
+        "code": code,
+        "raw": raw,
+    }

fr_cli/agent/manager.py

@@ -0,0 +1,193 @@
+"""
+Agent 管理器 —— 分身掌管者
+负责 Agent 目录的创建、删除、列出，以及设定的读写
+"""
+import shutil
+from pathlib import Path
+from fr_cli.agent import AGENTS_DIR
+
+
+PERSONA_FILE = "persona.md"
+MEMORY_FILE = "memory.md"
+SKILLS_FILE = "skills.md"
+AGENT_CODE_FILE = "agent.py"
+PROGRESS_FILE = "progress.json"
+
+
+def _agent_dir(name: str) -> Path:
+    """获取指定 Agent 的洞府路径"""
+    safe_name = "".join(c for c in name if c.isalnum() or c in ("_", "-"))
+    if not safe_name:
+        safe_name = "unnamed"
+    return AGENTS_DIR / safe_name
+
+
+def ensure_agents_dir():
+    """确保 Agents 总洞府存在"""
+    AGENTS_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def agent_exists(name: str) -> bool:
+    """检查分身是否已存在"""
+    return _agent_dir(name).exists()
+
+
+def create_agent_dir(name: str) -> Path:
+    """为新的 Agent 开辟独立洞府"""
+    ensure_agents_dir()
+    d = _agent_dir(name)
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+def list_agents() -> list:
+    """列出所有已创建的分身"""
+    if not AGENTS_DIR.exists():
+        return []
+    agents = []
+    for d in AGENTS_DIR.iterdir():
+        if d.is_dir() and (d / AGENT_CODE_FILE).exists():
+            agents.append({
+                "name": d.name,
+                "path": str(d),
+                "has_persona": (d / PERSONA_FILE).exists(),
+                "has_memory": (d / MEMORY_FILE).exists(),
+                "has_skills": (d / SKILLS_FILE).exists(),
+            })
+    return agents
+
+
+def delete_agent(name: str) -> bool:
+    """彻底抹除一个分身及其所有记忆"""
+    d = _agent_dir(name)
+    if not d.exists():
+        return False
+    shutil.rmtree(d)
+    return True
+
+
+# ---------- 设定读写 ----------
+
+def _read_md(agent_dir: Path, filename: str, default: str = "") -> str:
+    f = agent_dir / filename
+    if f.exists():
+        return f.read_text(encoding="utf-8")
+    return default
+
+
+def _write_md(agent_dir: Path, filename: str, content: str):
+    f = agent_dir / filename
+    f.write_text(content, encoding="utf-8")
+
+
+def load_persona(name: str) -> str:
+    return _read_md(_agent_dir(name), PERSONA_FILE, "")
+
+
+def save_persona(name: str, content: str):
+    _write_md(_agent_dir(name), PERSONA_FILE, content)
+
+
+def load_memory(name: str) -> str:
+    return _read_md(_agent_dir(name), MEMORY_FILE, "")
+
+
+def save_memory(name: str, content: str):
+    _write_md(_agent_dir(name), MEMORY_FILE, content)
+
+
+def load_skills(name: str) -> str:
+    return _read_md(_agent_dir(name), SKILLS_FILE, "")
+
+
+def save_skills(name: str, content: str):
+    _write_md(_agent_dir(name), SKILLS_FILE, content)
+
+
+def load_agent_code(name: str) -> str:
+    return _read_md(_agent_dir(name), AGENT_CODE_FILE, "")
+
+
+def save_agent_code(name: str, content: str):
+    _write_md(_agent_dir(name), AGENT_CODE_FILE, content)
+
+
+# ---------- 代码动态加载 ----------
+
+def load_agent_module(name: str):
+    """动态加载 Agent 的 Python 模块，返回模块对象"""
+    import importlib.util
+    agent_dir = _agent_dir(name)
+    code_path = agent_dir / AGENT_CODE_FILE
+    if not code_path.exists():
+        return None
+    spec = importlib.util.spec_from_file_location(f"fr_cli_agent_{name}", str(code_path))
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+# ---------- 定时任务进度读写 ----------
+
+import json
+from datetime import datetime
+
+
+def load_progress(name: str) -> dict:
+    """读取 Agent 的定时任务执行进度"""
+    f = _agent_dir(name) / PROGRESS_FILE
+    if not f.exists():
+        return {}
+    try:
+        return json.loads(f.read_text(encoding="utf-8"))
+    except Exception:
+        return {}
+
+
+def save_progress(name: str, data: dict):
+    """保存 Agent 的定时任务执行进度"""
+    f = _agent_dir(name) / PROGRESS_FILE
+    try:
+        f.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+    except Exception:
+        pass
+
+
+def append_progress(name: str, result: str, user_input: str = "", status: str = "success", max_history: int = 50):
+    """追加一条执行记录到 Agent 进度文件
+    
+    Args:
+        result: 执行结果摘要
+        user_input: 触发此次执行的输入（定时任务的 input 或用户输入）
+        status: success / error
+        max_history: 保留的最大历史记录数
+    """
+    progress = load_progress(name)
+    entry = {
+        "timestamp": datetime.now().isoformat(),
+        "input": user_input,
+        "result": result,
+        "status": status,
+    }
+    history = progress.get("history", [])
+    history.append(entry)
+    # 保留最近 max_history 条
+    if len(history) > max_history:
+        history = history[-max_history:]
+    progress["history"] = history
+    progress["latest"] = entry
+    progress["counter"] = progress.get("counter", 0) + 1
+    save_progress(name, progress)
+
+
+def get_latest_progress(name: str) -> dict:
+    """获取 Agent 最近一次执行进度"""
+    progress = load_progress(name)
+    return progress.get("latest", {})
+
+
+def get_progress_history(name: str, limit: int = 10) -> list:
+    """获取 Agent 执行历史记录"""
+    progress = load_progress(name)
+    history = progress.get("history", [])
+    return history[-limit:] if history else []