fr-cli 2.1.0__py3-none-any.whl

fr_cli/main.py

@@ -0,0 +1,329 @@
+"""
+凡人打字机 - 主脑控制台
+负责状态初始化、命令路由与 AI 交互循环
+"""
+import sys, os, subprocess, platform, shutil
+from pathlib import Path
+
+# 添加项目根目录到 Python 路径
+project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if project_root not in sys.path:
+    sys.path.insert(0, project_root)
+
+from fr_cli.conf.config import init_config, ConfigError
+from fr_cli.lang.i18n import T
+from fr_cli.ui.ui import enable_win_ansi, print_banner, print_bye, CYAN, RED, YELLOW, DIM, RESET
+from fr_cli.core.stream import stream_cnt
+from fr_cli.memory.history import load_sess
+from fr_cli.memory.context import load_context
+from fr_cli.core.core import AppState
+from fr_cli.core.chat import handle_ai_chat
+
+
+def _sync_manual_to_workspace(vfs):
+    """将项目根目录的 MANUAL.md 复制到工作空间，使 AI 可通过 read_file 读取"""
+    if not vfs.cwd:
+        return
+    try:
+        manual_src = Path(__file__).parent.parent / "MANUAL.md"
+        if not manual_src.exists():
+            return
+        manual_dst = Path(vfs.cwd) / "MANUAL.md"
+        if not manual_dst.exists():
+            import shutil
+            shutil.copy2(manual_src, manual_dst)
+    except Exception:
+        pass
+
+
+# ------------------------------------------------------------------
+# 命令路由函数（将 main() 中巨大的 if-elif 链提取为字典映射）
+# 返回 True 表示应退出主循环
+# ------------------------------------------------------------------
+
+from fr_cli.repl.commands import (
+    _cmd_exit,
+    _cmd_help,
+    _cmd_model,
+    _cmd_key,
+    _cmd_limit,
+    _cmd_lang,
+    _cmd_dir,
+    _cmd_dirs,
+    _cmd_rmdir,
+    _cmd_save,
+    _cmd_load,
+    _cmd_del,
+    _cmd_session_list,
+    _cmd_session_load,
+    _cmd_session_del,
+    _cmd_see,
+    _cmd_update,
+    _cmd_agent_server,
+    _cmd_mode,
+    _cmd_gatekeeper,
+    _cmd_open,
+    _cmd_launch,
+    _cmd_apps,
+    _cmd_agent_create,
+    _cmd_agent_list,
+    _cmd_agent_delete,
+    _cmd_agent_show,
+    _cmd_agent_run,
+    _cmd_agent_edit,
+    _cmd_agent_forge,
+    _cmd_remote_agent_add,
+    _cmd_remote_agent_list,
+    _cmd_remote_agent_del,
+    _cmd_agent_publish,
+    _cmd_remote_agent_scan,
+    _cmd_remote_agent_import,
+    _cmd_remote_setup,
+    _cmd_db_setup,
+    _cmd_agent_cron_add,
+    _cmd_agent_cron_list,
+    _cmd_agent_cron_del,
+    _cmd_rag_dir,
+    _cmd_rag_watch,
+    _cmd_rag_sync,
+    _cmd_read_excel,
+    _cmd_read_csv,
+    _cmd_master,
+    _cmd_mcp_list,
+    _cmd_mcp_add,
+    _cmd_mcp_del,
+    _cmd_mcp_enable,
+    _cmd_mcp_disable,
+    _cmd_mcp_refresh,
+)
+
+
+_COMMAND_ROUTES = {
+    "/exit": _cmd_exit,
+    "/quit": _cmd_exit,
+    "/help": _cmd_help,
+    "/model": _cmd_model,
+    "/key": _cmd_key,
+    "/limit": _cmd_limit,
+    "/lang": _cmd_lang,
+    "/mode": _cmd_mode,
+    "/dir": _cmd_dir,
+    "/dirs": _cmd_dirs,
+    "/rmdir": _cmd_rmdir,
+    "/save": _cmd_save,
+    "/load": _cmd_load,
+    "/del": _cmd_del,
+    "/session_list": _cmd_session_list,
+    "/session_load": _cmd_session_load,
+    "/session_del": _cmd_session_del,
+    "/see": _cmd_see,
+    "/update": _cmd_update,
+    "/agent_server": _cmd_agent_server,
+    "/gatekeeper": _cmd_gatekeeper,
+    "/open": _cmd_open,
+    "/launch": _cmd_launch,
+    "/apps": _cmd_apps,
+    "/agent_create": _cmd_agent_create,
+    "/agent_list": _cmd_agent_list,
+    "/agent_delete": _cmd_agent_delete,
+    "/agent_show": _cmd_agent_show,
+    "/agent_run": _cmd_agent_run,
+    "/agent_edit": _cmd_agent_edit,
+    "/agent_forge": _cmd_agent_forge,
+    "/remote_agent_add": _cmd_remote_agent_add,
+    "/remote_agent_list": _cmd_remote_agent_list,
+    "/remote_agent_del": _cmd_remote_agent_del,
+    "/agent_publish": _cmd_agent_publish,
+    "/remote_agent_scan": _cmd_remote_agent_scan,
+    "/remote_agent_import": _cmd_remote_agent_import,
+    "/remote_setup": _cmd_remote_setup,
+    "/db_setup": _cmd_db_setup,
+    "/agent_cron_add": _cmd_agent_cron_add,
+    "/agent_cron_list": _cmd_agent_cron_list,
+    "/agent_cron_del": _cmd_agent_cron_del,
+    "/rag_dir": _cmd_rag_dir,
+    "/rag_watch": _cmd_rag_watch,
+    "/rag_sync": _cmd_rag_sync,
+    "/read_excel": _cmd_read_excel,
+    "/read_csv": _cmd_read_csv,
+    "/master": _cmd_master,
+    "/mcp_list": _cmd_mcp_list,
+    "/mcp_add": _cmd_mcp_add,
+    "/mcp_del": _cmd_mcp_del,
+    "/mcp_enable": _cmd_mcp_enable,
+    "/mcp_disable": _cmd_mcp_disable,
+    "/mcp_refresh": _cmd_mcp_refresh,
+}
+
+
+def main():
+    enable_win_ansi()
+    try:
+        cfg = init_config()
+    except ConfigError:
+        print(f"{RED}配置初始化失败，退出。{RESET}")
+        return
+    state = AppState(cfg)
+
+    # 将 MANUAL.md 同步到工作空间
+    _sync_manual_to_workspace(state.vfs)
+
+    # 加载历史会话或初始化系统提示词
+    sp = T("sys_prompt", state.lang)
+    if state.sn:
+        ok, m, _ = load_sess(0, sp)
+        if ok:
+            state.messages = m
+    if not state.messages:
+        state.messages = [{"role": "system", "content": sp}]
+
+    # 加载当前会话的记忆上下文
+    state.context_summary = load_context(state.sn)
+
+    # 启动动画
+    print_banner(state.model_name, state.limit, cfg.get("allowed_dirs", [""]), state.sn, state.lang)
+
+    # ================= 主循环 =================
+    while True:
+        try:
+            u = input(f"{CYAN}>>> {RESET}").strip()
+        except (EOFError, KeyboardInterrupt):
+            print_bye()
+            break
+
+        if not u:
+            continue
+
+        # 替换别名
+        if u in state.aliases:
+            u = state.aliases[u]
+
+        # ----------------- 内置指令路由 -----------------
+        if u.startswith("/"):
+            parts = u.split()
+            cmd = parts[0].lower()
+            arg1 = parts[1] if len(parts) > 1 else ""
+
+            if cmd in _COMMAND_ROUTES:
+                if _COMMAND_ROUTES[cmd](state, parts):
+                    break
+            else:
+                # 其余命令统一委托给执行引擎
+                result, error = state.executor.execute(u, state.messages)
+                if error:
+                    print(f"{RED}{error}{RESET}")
+                elif result is not None:
+                    # 根据命令类型做简单格式化
+                    if cmd == "/cat" and arg1:
+                        print(f"\n{DIM}--- {arg1} ---{RESET}\n{result}\n{DIM}--- EOF ---{RESET}")
+                    elif cmd == "/fetch" and arg1:
+                        print(f"{DIM}--- Fetch ---{RESET}\n{result}\n{DIM}--- EOF ---{RESET}")
+                    elif cmd == "/skills":
+                        print("\n".join([f"{CYAN}{line}{RESET}" for line in result.split("\n")]))
+                    else:
+                        print(result)
+
+        # ----------------- 破壁指令 -----------------
+        elif u.startswith("!"):
+            is_pipe = "|" in u
+            shell_cmd = u[1:].split("|")[0].strip()
+
+            if state.security.check("sec_shell", shell_cmd):
+                try:
+                    if platform.system() == "Windows":
+                        ps_exe = shutil.which("pwsh") or shutil.which("powershell")
+                        if ps_exe:
+                            res = subprocess.run([ps_exe, "-Command", shell_cmd], capture_output=True, text=True, timeout=15)
+                        else:
+                            res = subprocess.run(shell_cmd, shell=True, capture_output=True, text=True, timeout=15)
+                    else:
+                        res = subprocess.run(shell_cmd, shell=True, capture_output=True, text=True, timeout=15)
+                    out = res.stdout + res.stderr
+                    if is_pipe:
+                        pipe_prompt = u.split("|", 1)[1].strip()
+                        final_prompt = f"{T('pipe_prefix', state.lang)}{out}\n\n{pipe_prompt}"
+                        if state.vfs.cwd:
+                            final_prompt += T("ctx_dir", state.lang, state.vfs.cwd)
+                        state.messages.append({"role": "user", "content": final_prompt})
+                        txt, _, response_time = stream_cnt(
+                            state.client, state.model_name, state.messages, state.lang,
+                            max_tokens=state.limit
+                        )
+                        state.messages.append({"role": "assistant", "content": txt})
+
+                        # 自动执行 AI 响应中的命令（与 handle_ai_chat 保持一致）
+                        clean_txt, cmd_results = state.executor.process_ai_commands(txt, state.messages)
+                        if cmd_results:
+                            print(f"\n{CYAN}🤖 自动执行命令:{RESET}")
+                            for result in cmd_results:
+                                print(f"{DIM}{result}{RESET}")
+                            state.messages[-1]["content"] = clean_txt if clean_txt.strip() else "[已执行命令]"
+                            state.messages.append({
+                                "role": "system",
+                                "content": f"命令执行结果:\n" + "\n".join(cmd_results)
+                            })
+                            sys.stdout.write(f"{CYAN}{T('prompt_ai', state.lang)}{RESET} ")
+                            sys.stdout.flush()
+                            final_txt, _, final_response_time = stream_cnt(
+                                state.client, state.model_name, state.messages, state.lang,
+                                custom_prefix="", max_tokens=state.limit
+                            )
+                            state.messages.append({"role": "assistant", "content": final_txt})
+                            response_time += final_response_time
+
+                        print(f"{DIM}📊 {T('stats_model', state.lang)}: {state.model_name} | {T('stats_time', state.lang)}: {response_time:.2f}{T('stats_seconds', state.lang)}{RESET}")
+                    else:
+                        if out.strip():
+                            print(out.strip()[:2000])
+                except subprocess.TimeoutExpired:
+                    print(f"{RED}Timeout{RESET}")
+                except Exception as e:
+                    print(f"{RED}{e}{RESET}")
+
+        # ----------------- 内置 Agent 前缀拦截 -----------------
+        elif u.startswith("@local "):
+            try:
+                from fr_cli.agent.builtins.local import handle_local
+                handle_local(u, state)
+            except Exception as e:
+                print(f"{RED}@local Agent 执行失败: {e}{RESET}")
+
+        elif u.startswith("@remote "):
+            try:
+                from fr_cli.agent.builtins.remote import handle_remote
+                handle_remote(u, state)
+            except Exception as e:
+                print(f"{RED}@remote Agent 执行失败: {e}{RESET}")
+
+        elif u.startswith("@spider "):
+            try:
+                from fr_cli.agent.builtins.spider import handle_spider
+                handle_spider(u, state)
+            except Exception as e:
+                print(f"{RED}@spider Agent 执行失败: {e}{RESET}")
+
+        elif u.startswith("@db "):
+            try:
+                from fr_cli.agent.builtins.db import handle_db
+                handle_db(u, state)
+            except Exception as e:
+                print(f"{RED}@db Agent 执行失败: {e}{RESET}")
+
+        elif u.startswith("@RAG ") or u.startswith("@rag "):
+            try:
+                from fr_cli.agent.builtins.rag import handle_rag
+                handle_rag(u, state)
+            except Exception as e:
+                print(f"{RED}@RAG Agent 执行失败: {e}{RESET}")
+
+        # ----------------- AI 正常对话 -----------------
+        else:
+            if state.master_agent.is_enabled():
+                reply, _ = state.master_agent.handle(u)
+                print(f"\n{CYAN}{reply}{RESET}")
+            else:
+                handle_ai_chat(state, u)
+
+
+if __name__ == "__main__":
+    main()

fr_cli/memory/context.py

@@ -0,0 +1,119 @@
+"""
+记忆上下文引擎
+保存并注入最近 N 轮对话的总结，作为 system prompt 的上下文
+让每个会话拥有独立的短期记忆
+"""
+import json
+import re
+from pathlib import Path
+from datetime import datetime
+
+CONTEXT_FILE = Path.home() / ".zhipu_cli_context.json"
+
+
+def extract_recent_turns(messages, n=5):
+    """
+    从消息列表中提取最近 n 轮 user/assistant 对话
+    :param messages: 完整消息历史
+    :param n: 轮数（每轮包含 user + assistant）
+    :return: list of dict, 最多 n*2 条消息
+    """
+    chat_msgs = [m for m in messages if m.get("role") in ("user", "assistant")]
+    return chat_msgs[-n * 2:]
+
+
+def build_context_summary(turns, lang="zh"):
+    """
+    将对话轮次格式化为上下文摘要文本
+    :param turns: extract_recent_turns 返回的消息列表
+    :param lang: 语言
+    :return: str 摘要文本（空字符串表示无内容）
+    """
+    if not turns:
+        return ""
+
+    header = "\n\n[当前会话上下文摘要]\n" if lang == "zh" else "\n\n[Session Context Summary]\n"
+    lines = []
+
+    for m in turns:
+        role = "用户" if m.get("role") == "user" else "AI"
+        content = m.get("content", "")
+
+        # 处理多模态消息（图片等）
+        if isinstance(content, list):
+            content = "[图片/多模态消息]"
+        elif isinstance(content, str):
+            # 去除命令标记，避免重复噪音
+            content = re.sub(r'【命令：(.*?)】', '', content)
+            content = content.strip()
+            if not content:
+                content = "[已执行命令]"
+            elif len(content) > 200:
+                content = content[:200] + "..."
+
+        lines.append(f"{role}：{content}")
+
+    return header + "\n".join(lines) + "\n"
+
+
+def save_context(session_name, summary):
+    """
+    按会话名持久化上下文摘要
+    :param session_name: 会话名（空字符串时使用 __default__）
+    :param summary: 摘要文本
+    """
+    data = {}
+    if CONTEXT_FILE.exists():
+        try:
+            with open(CONTEXT_FILE, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+        except Exception:
+            pass
+
+    key = session_name if session_name else "__default__"
+    data[key] = {
+        "summary": summary,
+        "ts": datetime.now().isoformat()
+    }
+
+    try:
+        with open(CONTEXT_FILE, 'w', encoding='utf-8') as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+    except Exception:
+        pass
+
+
+def load_context(session_name):
+    """
+    按会话名加载上下文摘要
+    :param session_name: 会话名
+    :return: str 摘要文本（不存在时返回空字符串）
+    """
+    if not CONTEXT_FILE.exists():
+        return ""
+    try:
+        with open(CONTEXT_FILE, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        key = session_name if session_name else "__default__"
+        return data.get(key, {}).get("summary", "")
+    except Exception:
+        return ""
+
+
+def clear_context(session_name):
+    """
+    清除指定会话的上下文摘要
+    :param session_name: 会话名
+    """
+    if not CONTEXT_FILE.exists():
+        return
+    try:
+        with open(CONTEXT_FILE, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        key = session_name if session_name else "__default__"
+        if key in data:
+            del data[key]
+        with open(CONTEXT_FILE, 'w', encoding='utf-8') as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+    except Exception:
+        pass

fr_cli/memory/history.py

@@ -0,0 +1,96 @@
+"""
+会话轮回管理引擎
+负责对话历史的本地保存、加载、删除与 Markdown 导出
+"""
+import json, os
+from pathlib import Path
+from datetime import datetime
+from fr_cli.lang.i18n import T
+from fr_cli.ui.ui import RED, RESET
+
+HIST_DIR = Path.home() / ".zhipu_cli_history"
+
+def init_history():
+    """确保历史目录存在"""
+    HIST_DIR.mkdir(parents=True, exist_ok=True)
+
+def _fpath(name):
+    return HIST_DIR / f"{name}.json"
+
+def get_sessions():
+    """获取所有会话列表"""
+    init_history()
+    sess = []
+    for f in sorted(HIST_DIR.glob("sess_*.json"), key=os.path.getmtime, reverse=True):
+        try:
+            with open(f, 'r', encoding='utf-8') as fp:
+                data = json.load(fp)
+            sess.append({"file": f.name, "name": data.get("name", f.stem)})
+        except Exception:
+            pass
+    return sess
+
+def save_sess(name, msgs):
+    """保存当前对话到轮回石"""
+    init_history()
+    safe_name = "".join(c for c in name if c.isalnum() or c in ('_', '-'))
+    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+    fname = f"sess_{ts}_{safe_name}"
+    fp = _fpath(fname)
+    try:
+        with open(fp, 'w', encoding='utf-8') as f:
+            json.dump({"name": name, "ts": ts, "msgs": msgs}, f, ensure_ascii=False, indent=2)
+        return True
+    except Exception as e: 
+        print(f"{RED}{e}{RESET}")
+        return False
+
+def load_sess(index, sp):
+    """从轮回石中加载指定索引的会话"""
+    ss = get_sessions()
+    if not ss or index >= len(ss): return False, None, None
+    fp = HIST_DIR / ss[index]["file"]
+    try:
+        with open(fp, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        msgs = data.get("msgs", [])
+        # 强制覆盖第一条为最新的系统提示词
+        if msgs and msgs[0]["role"] == "system":
+            msgs[0]["content"] = sp
+        else:
+            msgs.insert(0, {"role": "system", "content": sp})
+        return True, msgs, data.get("name")
+    except Exception as e: 
+        print(f"{RED}{e}{RESET}")
+        return False, None, None
+
+def del_sess(index):
+    """斩断一段因果(删除会话)"""
+    ss = get_sessions()
+    if not ss or index >= len(ss): return
+    fp = HIST_DIR / ss[index]["file"]
+    try:
+        os.remove(fp)
+        return True
+    except Exception:
+        return False
+
+def export_md(msgs, lang, out_dir=None):
+    """将当前会话导出为 Markdown 文件
+    :param out_dir: 用户设定的工作目录，若提供且存在则保存到该目录，否则保存到当前运行目录
+    """
+    if not msgs: return False, T("empty", lang)
+    ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+    fname = f"glm_export_{ts}.md"
+    try:
+        target_dir = out_dir if out_dir and os.path.isdir(out_dir) else "."
+        fpath = os.path.join(target_dir, fname)
+        with open(fpath, 'w', encoding='utf-8') as f:
+            for m in msgs:
+                role = m.get("role", "unknown")
+                content = m.get("content", "")
+                if role == "system": continue
+                tag = "### 🧑 凡人" if role == "user" else "### 🧙 飞书"
+                f.write(f"{tag}\n\n{content}\n\n---\n\n")
+        return True, fpath
+    except Exception as e: return False, str(e)

fr_cli/memory/session.py

@@ -0,0 +1,134 @@
+"""
+自动会话存档引擎 —— 按日期轮回
+每次启动自动创建日期编号会话文件，实时追加对话记录。
+"""
+import json
+import os
+from datetime import datetime
+from pathlib import Path
+
+SESSION_DIR = Path.home() / ".fr_cli_sessions"
+
+
+def _ensure_dir():
+    SESSION_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def _list_session_files():
+    """返回所有会话文件路径列表（按修改时间倒序）"""
+    _ensure_dir()
+    files = list(SESSION_DIR.glob("*.json"))
+    files.sort(key=lambda p: p.stat().st_mtime, reverse=True)
+    return files
+
+
+def _get_next_session_filename():
+    """根据日期生成下一个可用会话文件名 YYYY-MM-DD_01.json, YYYY-MM-DD_02.json ..."""
+    _ensure_dir()
+    today = datetime.now().strftime("%Y-%m-%d")
+    existing = [f.stem for f in SESSION_DIR.glob(f"{today}_*.json")]
+    nums = []
+    for stem in existing:
+        parts = stem.split("_")
+        if len(parts) == 2 and parts[1].isdigit():
+            nums.append(int(parts[1]))
+    next_num = max(nums, default=0) + 1
+    return f"{today}_{next_num:02d}.json"
+
+
+def create_session(messages):
+    """创建新的自动会话文件，返回文件路径"""
+    _ensure_dir()
+    fname = _get_next_session_filename()
+    fpath = SESSION_DIR / fname
+    data = {
+        "filename": fname,
+        "created_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        "updated_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        "messages": messages,
+    }
+    try:
+        with open(fpath, "w", encoding="utf-8") as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+        return str(fpath)
+    except Exception:
+        return None
+
+
+def update_session(fpath, messages):
+    """更新会话文件中的消息记录"""
+    if not fpath:
+        return False
+    try:
+        path = Path(fpath)
+        data = {}
+        if path.exists():
+            with open(path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+        data["updated_at"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        data["messages"] = messages
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+        return True
+    except Exception:
+        return False
+
+
+def list_sessions():
+    """列出所有会话，返回元数据列表"""
+    files = _list_session_files()
+    result = []
+    for idx, fpath in enumerate(files, start=1):
+        try:
+            with open(fpath, "r", encoding="utf-8") as f:
+                data = json.load(f)
+            created = data.get("created_at", "未知")
+            updated = data.get("updated_at", "未知")
+            msg_count = len(data.get("messages", []))
+            result.append({
+                "index": idx,
+                "filename": fpath.name,
+                "created_at": created,
+                "updated_at": updated,
+                "msg_count": msg_count,
+                "path": str(fpath),
+            })
+        except Exception:
+            pass
+    return result
+
+
+def load_session(index, current_system_prompt=None):
+    """按索引加载会话消息
+    :param index: 1-based 索引
+    :param current_system_prompt: 若提供，将覆盖第一条 system prompt
+    :return: (success, messages, filename)
+    """
+    sessions = list_sessions()
+    if not sessions or index < 1 or index > len(sessions):
+        return False, None, None
+    target = sessions[index - 1]
+    try:
+        with open(target["path"], "r", encoding="utf-8") as f:
+            data = json.load(f)
+        msgs = data.get("messages", [])
+        if current_system_prompt and msgs and msgs[0]["role"] == "system":
+            msgs[0]["content"] = current_system_prompt
+        elif current_system_prompt:
+            msgs.insert(0, {"role": "system", "content": current_system_prompt})
+        return True, msgs, target["filename"]
+    except Exception:
+        return False, None, None
+
+
+def delete_session(index):
+    """按索引删除会话文件"""
+    sessions = list_sessions()
+    if not sessions or index < 1 or index > len(sessions):
+        return False
+    target = sessions[index - 1]
+    try:
+        os.remove(target["path"])
+        return True
+    except Exception:
+        return False