nexforge-cli 0.1.0__py3-none-any.whl

nexforge/ui/screens/chat.py

@@ -0,0 +1,825 @@
+"""ChatScreen —— NexForgeCLI 主交互界面。
+
+流程:用户输入 → 挂载 UserMessage → 后台 worker 跑 AgentLoop →
+按事件流实时更新思考面板 / 正文 / 工具卡片 / 状态栏。
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from textual import work
+from textual.app import ComposeResult
+from textual.containers import Horizontal, Vertical, VerticalScroll
+from textual.screen import Screen
+from textual.widgets import Button, Label, Static
+from nexforge.ui.widgets.multiline_prompt import MultilinePrompt
+import asyncio
+
+from nexforge.config import NexForgeConfig
+from nexforge.core.agent import AgentEventKind, AgentLoop
+from nexforge.core.session import Session
+from nexforge.provider.deepseek import DeepSeekProvider, ProviderError
+from nexforge.ui.widgets.banner import Banner
+from nexforge.ui.widgets.apikey_modal import ApiKeyModal
+from nexforge.ui.widgets.confirm_modal import ConfirmModal
+from nexforge.ui.widgets.diff_modal import DiffApprovalModal
+from nexforge.ui.widgets.mode_warning import ModeWarningModal
+from nexforge.ui.widgets.multiline_modal import MultilineInputModal
+from nexforge.ui.widgets.messages import (
+    AssistantTurn,
+    SystemNote,
+    ToolCard,
+    UserMessage,
+)
+from nexforge.ui.widgets.statusbar import StatusBar
+from nexforge.ui.widgets.sidebar import Sidebar
+from nexforge.ui.widgets.plan_sidebar import PlanSidebar
+from nexforge.skills.loader import Skill, discover_skills, skill_index_str
+from nexforge.store.session_store import _next_id, _today_dir, list_sessions, save_session
+import nexforge.store.plan_store as plan_store
+
+HELP = """\
+  /help              显示本帮助
+  /key sk-...        保存 API Key(只写一次,后续自动生效)
+  /model flash|pro|auto   切换模型档位
+  /think on|off      开关思考模式
+  /mode review|auto  审批模式(review 每次审批, auto 直接执行)
+  /plan              切换计划模式(只读讨论,不写文件)
+  /json              切换 JSON 输出模式
+  /balance           查询 DeepSeek 账户余额
+  /perm <safe|supervised|auto>  切换权限级别
+    safe        🛡 审核模式:全部写/删/Shell 需审批
+    supervised  ⚡ 半自动:写文件自动,删/Shell需审批(默认)
+    auto        🔥 全自动:全部直接执行
+  /skill <name>      执行指定技能(先 /skills 列清单)
+  /skills            列出可用的 SKILL.md 技能
+  /save [name]        保存当前对话并命名
+  /rename <name>      重命名当前会话
+  /sessions           列出历史会话
+  /cost              显示累计费用
+  /clear             清空当前会话
+  /quit              退出
+  /web start|stop     Web 管理面板
+快捷键:Esc 退出(确认) · Ctrl+L 清屏 · F1 帮助"""
+
+
+class ChatScreen(Screen):
+    BINDINGS = [
+        ("escape", "quit_with_confirm", "退出"),
+        ("ctrl+l", "clear_log", "清屏"),
+        ("pageup", "scroll_up", "上滚"),
+        ("pagedown", "scroll_down", "下滚"),
+        ("up", "line_up", "上一行"),
+        ("down", "line_down", "下一行"),
+        ("end", "scroll_bottom", "回底"),
+        ("ctrl+s", "toggle_sidebar", "会话"),
+        ("ctrl+b", "toggle_plan", "计划"),
+        ("f1", "show_help", "帮助"),
+        ("f2", "multiline_input", "多行"),
+    ]
+
+    def __init__(
+        self, config: NexForgeConfig, resume_session_id: str | None = None
+    ) -> None:
+        super().__init__()
+        self.config = config
+        self.session = Session()
+        self.provider: DeepSeekProvider | None = None
+        self.agent: AgentLoop | None = None
+        self._pending_card: ToolCard | None = None
+        self._current_turn: AssistantTurn | None = None
+        self._skills: list[Skill] = []
+        self._sidebar: Sidebar | None = None
+        self._plan_sidebar: PlanSidebar | None = None
+        self._balance: str = ""
+        self._session_id: str = ""
+        self._session_name: str = ""
+        self._follow: bool = True  # 流式时自动跟底,用户上滚后暂停
+        self._scroll_pending: bool = False  # 滚动节流:同一刷新周期只排一次
+        self._agent_running: bool = False
+
+    def compose(self) -> ComposeResult:
+        yield Banner(id="banner")
+        with Horizontal():
+            with Vertical(id="main-area"):
+                yield VerticalScroll(id="chat-log")
+                yield StatusBar(id="status")
+                yield MultilinePrompt(id="prompt")
+                yield Label("Enter 发送 · F1 帮助 · F2 多行 · Esc 停止/退出 · /help 命令", id="prompt-hint")
+            self._sidebar = Sidebar(id="sidebar")
+            yield self._sidebar
+            self._plan_sidebar = PlanSidebar(id="plan-sidebar")
+            yield self._plan_sidebar
+        self._sidebar.display = False  # 初始隐藏
+        self._plan_sidebar.display = False
+
+    def on_mount(self) -> None:
+        self.query_one("#prompt", MultilinePrompt).focus()
+        # 加载技能
+        self._skills = discover_skills(Path.cwd())
+        if not self.config.resolve_api_key():
+            # 弹出 API Key 输入面板
+            async def _ask_key():
+                key = await self.app.push_screen_wait(ApiKeyModal())
+                if key:
+                    from nexforge.config import save_api_key
+                    save_api_key(key)
+                    self.config.provider.api_key = key
+                    self._init_provider()
+            import asyncio
+            asyncio.create_task(_ask_key())
+        else:
+            self._init_provider()
+        self._refresh_status()
+        if self.config.ui.mode == "auto":
+            self._note(
+                "⚠ 全自动模式(所有写/删/命令不经审批)。用 /mode review 切换。",
+                error=True,
+            )
+        self._auto_resume()
+        # 自动查询余额
+        self._auto_fetch_balance()
+        # 启动 splash(1.5s 后自动消失)
+        self._auto_fetch_balance()
+
+    # ---- 输入处理 ---------------------------------------------------------
+
+    async def on_multiline_prompt_prompt_submitted(self, event: MultilinePrompt.PromptSubmitted) -> None:
+        text = event.text.strip()
+        if not text:
+            return
+        if text.startswith("/"):
+            await self._handle_slash(text)
+            return
+        if self.agent is None:
+            self._note("未初始化(缺少 API Key),无法对话。", error=True)
+            return
+        self._set_follow(True)  # 每次新对话重置跟底
+        self._agent_running = True
+        self._refresh_status()
+        prompt = self.query_one("#prompt", MultilinePrompt)
+        prompt.read_only = True
+        await self._mount(UserMessage(text))
+        self._run_agent(text)
+
+    async def _handle_slash(self, text: str) -> None:
+        parts = text[1:].split()
+        cmd = parts[0].lower() if parts else ""
+        arg = parts[1] if len(parts) > 1 else ""
+
+        if cmd == "help":
+            self._note(HELP)
+        elif cmd == "key":
+            if not arg.startswith("sk-"):
+                self._note("格式: /key sk-你的完整密钥", error=True)
+                return
+            from nexforge.config import save_api_key
+
+            save_api_key(arg)
+            self.config.provider.api_key = arg
+            try:
+                self.provider = DeepSeekProvider(self.config)
+                self.agent = AgentLoop(
+                    self.config, self.provider, self.session, approve=self._ask_approve
+                )
+                self._note("API Key 已保存并生效!")
+            except ProviderError as exc:
+                self._note(str(exc), error=True)
+            return
+        elif cmd == "quit" or cmd == "exit":
+            self.app.exit()
+        elif cmd == "clear":
+            self.session = Session()
+            if self.provider is not None:
+                self.agent = AgentLoop(
+                    self.config, self.provider, self.session, approve=self._ask_approve
+                )
+            await self.query_one("#chat-log", VerticalScroll).remove_children()
+            self._note("已清空会话。")
+        elif cmd == "model" and arg in ("flash", "pro", "auto"):
+            self.config.models.default_tier = arg  # type: ignore[assignment]
+            self._note(f"模型档位 -> {arg}")
+        elif cmd == "think" and arg in ("on", "off"):
+            self.config.models.thinking = arg == "on"
+            self._note(f"思考模式 -> {arg}")
+        elif cmd == "mode" and arg == "auto":
+            # 推警告弹窗,回调中处理确认/取消
+            def _on_auto_confirm(result: bool) -> None:
+                if result:
+                    self.config.ui.mode = "auto"  # type: ignore[assignment]
+                    self._note("已开启全自动模式(⚠ 所有写/删/命令操作不经审批)")
+                else:
+                    self._note("已取消")
+            self.app.push_screen(ModeWarningModal(), callback=_on_auto_confirm)
+        elif cmd == "plan":
+            self.config.ui.plan_mode = not self.config.ui.plan_mode
+            state = "已开启" if self.config.ui.plan_mode else "已关闭"
+            self._note(f"计划模式 {state}", scroll=True)
+            if self.config.ui.plan_mode:
+                self.session.messages.insert(1, {"role": "system", "content": "[计划模式]你处于规划阶段,只能读取和分析,不能修改任何文件或执行命令。"})
+            return
+        elif cmd == "json":
+            self.config.ui.json_mode = not self.config.ui.json_mode
+            state = "开启" if self.config.ui.json_mode else "关闭"
+            self._note(f"JSON 模式已{state}", scroll=True)
+            return
+        elif cmd == "perm" and arg in ("safe", "supervised", "auto"):
+            self.config.permissions.profile = arg
+            self._note(f"权限级别 → {arg}", scroll=True)
+            self._refresh_status()
+            return
+            state = "已开启" if self.config.ui.plan_mode else "已关闭"
+            self._note(f"计划模式 {state}。{'只读讨论,不写文件。' if self.config.ui.plan_mode else '恢复开发模式。'}", scroll=True)
+            if self.config.ui.plan_mode:
+                # 注入系统提示
+                self.session.messages.insert(
+                    1,
+                    {"role": "system", "content": "[计划模式:你处于规划阶段,只能读取和分析,不能修改任何文件或执行命令。请与用户讨论优化计划,不要调用写/删/Shell工具。]"},
+                )
+            return
+        elif cmd == "mode" and arg == "review":
+            self.config.ui.mode = "review"  # type: ignore[assignment]
+            self._note("审批模式 -> review(每次写/删/命令需确认)")
+        elif cmd == "skill" and arg:
+            sk = next((s for s in self._skills if s.name == arg), None)
+            if sk is None:
+                self._note(f"未知技能:{arg}(用 /skills 列清单)", error=True, scroll=True)
+                return
+            # 注入技能正文为一次性 system 消息
+            self.session.messages.insert(1, {"role": "system", "content": sk.body})
+            self._note(f"技能已激活:{sk.name} — {sk.description or '无描述'}", scroll=True)
+            return
+        elif cmd == "skills":
+            if not self._skills:
+                self._note("无可用技能。在 ~/.nexforge/skills/ 或 .nexforge/skills/ 放 SKILL.md。")
+                return
+            lines = ["\n".join(
+                f"/skill {s.name} — {s.description}" for s in self._skills
+            )]
+            self._note(lines[0])
+            return
+        elif cmd == "save":
+            self._save_as(arg or self._session_name or "manual")
+            return
+        elif cmd == "rename" and arg:
+            self._session_name = arg
+            if self._session_id:
+                save_session(self._session_id, arg, self.session.messages)
+            if self._sidebar:
+                self.call_later(self._sidebar.refresh_list)
+            self._note(f"已重命名为:{arg}", scroll=True)
+            return
+        elif cmd == "web" and arg == "start":
+            from nexforge.web.server import start_web
+            msg = start_web(self)
+            self._note(msg, scroll=True)
+            return
+        elif cmd == "web" and arg == "stop":
+            from nexforge.web.server import stop_web
+            msg = stop_web()
+            self._note(msg, scroll=True)
+            return
+            if self._session_id:
+                save_session(self._session_id, arg, self.session.messages)
+            if self._sidebar:
+                self.call_later(self._sidebar.refresh_list)
+            self._note(f"已重命名为:{arg}", scroll=True)
+            return
+        elif cmd == "sessions":
+            infos = list_sessions()
+            if not infos:
+                self._note("无历史会话。")
+                return
+            lines = [
+                f"{s.created}  {s.id}  ({s.message_count} 条消息)"
+                for s in infos[:15]
+            ]
+            self._note("\n".join(lines))
+            return
+        elif cmd == "cost":
+            u = self.session.total_usage
+            cost = u.cost_usd(self.config.price(self.config.models.default_tier))
+            self._note(
+                f"累计:输入 {u.prompt_tokens} · 输出 {u.completion_tokens} · ~${cost:.4f}"
+            )
+        else:
+            self._note(f"未知命令:{text}(/help 查看)", error=True)
+        self._refresh_status()
+        # 延迟滚动:等 SystemNote 被 call_later 挂载完成后再滚底
+        log = self.query_one("#chat-log", VerticalScroll)
+        self.set_timer(0.15, lambda: log.scroll_end(animate=False))
+
+    # ---- Agent 事件流 -----------------------------------------------------
+
+    @work(exclusive=True, group="agent")
+    async def _run_agent(self, text: str) -> None:
+        assert self.agent is not None
+        prompt = self.query_one("#prompt", MultilinePrompt)
+        try:
+            async for ev in self.agent.run_turn(text):
+                if ev.kind is AgentEventKind.ROUTE:
+                    self._current_turn = AssistantTurn()
+                    await self._mount(self._current_turn)
+                    if ev.route is not None:
+                        self._refresh_status(
+                            tier=ev.route.tier, thinking=ev.route.thinking
+                        )
+                elif ev.kind is AgentEventKind.REASONING:
+                    if self._current_turn:
+                        self._current_turn.add_reasoning(ev.text)
+                        self._scroll()
+                elif ev.kind is AgentEventKind.CONTENT:
+                    if self._current_turn:
+                        self._current_turn.add_content(ev.text)
+                        self._scroll()
+                elif ev.kind is AgentEventKind.TOOL_START:
+                    from nexforge.icons import tool_icon
+
+                    card = ToolCard(ev.tool_preview, icon_name=ev.tool_name)
+                    self._pending_card = card
+                    await self._mount(card)
+                elif ev.kind is AgentEventKind.TOOL_END:
+                    if self._pending_card:
+                        self._pending_card.set_result(ev.tool_ok, ev.tool_summary)
+                        self._pending_card = None
+                    self._scroll()
+                elif ev.kind is AgentEventKind.TURN_DONE:
+                    # 回合结束:Static 切 Markdown,然后保存+跟底
+                    if self._current_turn:
+                        self._current_turn.finalize_content()
+                    # plan 模式:自动保存计划文件+刷新面板
+                    if self.config.ui.plan_mode and ev.message and ev.message.content:
+                        self._save_plan_from_response(ev.message.content)
+                    self._auto_save()
+                    self._refresh_status()
+                    # 最后跟底:等当前刷新完成+延迟 0.05s,确保最后一段 Markdown 渲染完
+                    log = self.query_one("#chat-log", VerticalScroll)
+                    self.call_after_refresh(lambda: log.scroll_end(animate=False))
+                    self.set_timer(0.05, lambda: log.scroll_end(animate=False))
+                elif ev.kind is AgentEventKind.ERROR:
+                    await self._mount(SystemNote(ev.text, error=True))
+        finally:
+            self._agent_running = False
+            self._refresh_status()
+            prompt.read_only = False
+            prompt.focus()
+
+    # ---- 辅助 -------------------------------------------------------------
+
+    async def _mount(self, widget) -> None:
+        log = self.query_one("#chat-log", VerticalScroll)
+        at_bottom = log.scroll_y >= log.max_scroll_y - 3
+        await log.mount(widget)
+        if at_bottom:
+            self.call_after_refresh(lambda: log.scroll_end(animate=False))
+        # 屏幕上下文上限:超过 150 个 widget 删最旧的
+        self._trim_chat_log(log)
+
+    def _scroll(self) -> None:
+        """基于位置的跟底:内容变化前若已贴底则跟随;
+        用户滚上去(含鼠标拖动)自然不跟,不会与用户打架。"""
+        log = self.query_one("#chat-log", VerticalScroll)
+        if log.scroll_y >= log.max_scroll_y - 3:
+            if self._scroll_pending:
+                return
+            self._scroll_pending = True
+
+            def _do() -> None:
+                self._scroll_pending = False
+                log.scroll_end(animate=False)
+
+            self.call_after_refresh(_do)
+
+    def _set_follow(self, on: bool) -> None:
+        """on=True 时强制滚到底(新回合/回底键);on=False 不做事。
+        不再用 anchor(),避免与鼠标拖动拉锄导致卡死。"""
+        self._follow = on
+        if on:
+            try:
+                log = self.query_one("#chat-log", VerticalScroll)
+                self.call_after_refresh(lambda: log.scroll_end(animate=False))
+            except Exception:
+                pass
+
+    def _note(self, text: str, *, error: bool = False, scroll: bool = False) -> None:
+        if scroll:
+            log = self.query_one("#chat-log", VerticalScroll)
+            self.call_later(lambda: self._mount_then_scroll(SystemNote(text, error=error), log))
+        else:
+            self.call_later(self._mount, SystemNote(text, error=error))
+
+    async def _mount_then_scroll(self, widget, log) -> None:
+        await self._mount(widget)
+        log.scroll_end(animate=False)
+
+    def _refresh_status(
+        self, *, tier: str | None = None, thinking: bool | None = None
+    ) -> None:
+        u = self.session.total_usage
+        cost = u.cost_usd(self.config.price(self.config.models.default_tier))
+        self.query_one("#status", StatusBar).render_stats(
+            tier=tier or self.config.models.default_tier,
+            thinking=self.config.models.thinking if thinking is None else thinking,
+            ctx_tokens=self.session.approx_context_tokens(),
+            cost=cost,
+            plan_mode=self.config.ui.plan_mode,
+            perm=self.config.permissions.profile,
+            balance=getattr(self, "_balance", ""),
+        )
+
+    def action_clear_log(self) -> None:
+        self.run_worker(self.query_one("#chat-log", VerticalScroll).remove_children())
+
+    def action_scroll_up(self) -> None:
+        self.query_one("#chat-log", VerticalScroll).scroll_page_up()
+
+    def action_scroll_down(self) -> None:
+        self.query_one("#chat-log", VerticalScroll).scroll_page_down()
+
+    def action_line_up(self) -> None:
+        self.query_one("#chat-log", VerticalScroll).scroll_up()
+
+    def action_line_down(self) -> None:
+        self.query_one("#chat-log", VerticalScroll).scroll_down()
+
+    def action_toggle_sidebar(self) -> None:
+        if self._sidebar:
+            self._sidebar.display = not self._sidebar.display
+        self._scroll_to_bottom()
+
+    def action_toggle_plan(self) -> None:
+        if self._plan_sidebar:
+            self._plan_sidebar.display = not self._plan_sidebar.display
+        self._scroll_to_bottom()
+
+    def action_show_help(self) -> None:
+        self._note(HELP, scroll=True)
+
+    def action_multiline_input(self) -> None:
+        def _on_submit(text: str | None) -> None:
+            if text:
+                self._set_follow(True)
+                self._agent_running = True
+                self._refresh_status()
+                log = self.query_one("#chat-log", VerticalScroll)
+                log.mount(UserMessage(text))
+                self.query_one("#prompt", MultilinePrompt).disabled = True
+                self._run_agent(text)
+        self.app.push_screen(MultilineInputModal(), callback=_on_submit)
+
+    def _scroll_to_bottom(self) -> None:
+        log = self.query_one("#chat-log", VerticalScroll)
+        self.call_after_refresh(lambda: log.scroll_end(animate=False))
+
+    def _init_provider(self) -> None:
+        try:
+            self.provider = DeepSeekProvider(self.config)
+            self.agent = AgentLoop(
+                self.config, self.provider, self.session, approve=self._ask_approve
+            )
+        except ProviderError as exc:
+            self._note(str(exc), error=True)
+
+    def _auto_fetch_balance(self) -> None:
+        """启动时自动查询余额(不阻塞)。"""
+        key = self.config.resolve_api_key()
+        if not key:
+            return
+        async def _query():
+            from nexforge.provider.balance import fetch_balance
+            result = await fetch_balance(key)
+            self._balance = result
+            self._refresh_status()
+        import asyncio
+        asyncio.create_task(_query())
+
+    def _trim_chat_log(self, log: VerticalScroll) -> None:
+        """屏幕上下文上限 150 个 widget,超过则删最旧的(本地文件有记录)。"""
+        MAX_WIDGETS = 150
+        children = list(log.children)
+        if len(children) > MAX_WIDGETS:
+            excess = len(children) - MAX_WIDGETS + 20  # 多删一些避免频繁触发
+            for old in children[:excess]:
+                try:
+                    old.remove()
+                except Exception:
+                    pass
+
+    # ---- 侧边栏按钮处理 ---------------------------------------------------
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        bid = event.button.id or ""
+        if bid == "btn-new":
+            self._do_new_session()
+        elif bid == "btn-plan-clear":
+            if self._plan_sidebar:
+                self._plan_sidebar.clear()
+        elif bid == "btn-plan-new":
+            self.config.ui.plan_mode = True
+            self._note("计划模式已开启。请描述需求,AI 会生成计划。", scroll=True)
+        elif bid == "btn-plan-toggle":
+            self.config.ui.plan_mode = not self.config.ui.plan_mode
+            state = "已开启" if self.config.ui.plan_mode else "已关闭"
+            self._note(f"计划模式 {state}", scroll=True)
+            self._update_plan_toggle_button()
+        elif bid == "btn-plan-del":
+            self._delete_plan_with_confirm()
+        elif bid and bid.startswith("plan-"):
+            self._load_plan_to_main(bid)
+        elif bid == "btn-del":
+            self._do_delete_session()
+        elif bid and bid.startswith("sess-"):
+            self._do_switch_session(bid)
+
+    # ---- 计划文件操作 ---------------------------------------------------
+
+    def _save_plan_from_response(self, content: str) -> None:
+        first_line = content.split("\n")[0].strip()
+        title = first_line.lstrip("#").strip() if first_line.startswith("#") else "新计划"
+        plan_store.save_plan(title, content)
+        if self._plan_sidebar:
+            self.call_after_refresh(self._plan_sidebar.refresh_list)
+
+    def _load_plan_to_main(self, bid: str) -> None:
+        if self._plan_sidebar is None:
+            return
+        info = self._plan_sidebar.plan_map.get(bid)
+        if info is None:
+            return
+        md_text = plan_store.load_plan(info.id)
+        if md_text is None:
+            self._note("无法加载计划文件(可能已被删除)。", error=True, scroll=True)
+            self.call_after_refresh(self._plan_sidebar.refresh_list)
+            return
+        # 标题行
+        self._note(f"📋 {info.title}  ({info.done}/{info.total} 已完成)", scroll=True)
+        # 正文用 Rich Markdown 渲染(无截断 bug)
+        from rich.markdown import Markdown as RichMarkdown
+        # 先移除旧计划(避免 DuplicateIds)
+        try:
+            self.query_one("#plan-rt", Static).remove()
+        except Exception:
+            pass
+        rich_md = RichMarkdown(md_text)
+        md_widget = Static(rich_md, id="plan-rt")
+        log = self.query_one("#chat-log", VerticalScroll)
+        self.call_later(lambda: log.mount(md_widget))
+        self.call_later(lambda: log.scroll_end(animate=False))
+        # 激活计划 + 绿点
+        self._plan_sidebar.active_id = info.id
+        self.call_after_refresh(self._plan_sidebar.refresh_list)
+        # 注入计划上下文
+        self.session.messages.insert(1, {"role": "system", "content": f"[当前计划]{info.title}\n{md_text}\n请围绕以上计划工作,完成一项用[x]标记。"})
+
+    def _update_plan_toggle_button(self) -> None:
+        try:
+            btn = self.query_one("#btn-plan-toggle")
+        except Exception:
+            return
+        if self.config.ui.plan_mode:
+            btn.label = "关闭计划模式"
+            btn.variant = "error"
+        else:
+            btn.label = "开启计划模式"
+            btn.variant = "primary"
+
+    def _delete_plan_with_confirm(self) -> None:
+        if self._plan_sidebar is None or not self._plan_sidebar.active_id:
+            self._note("没有选中的计划。", error=True, scroll=True)
+            return
+        plan_id = self._plan_sidebar.active_id
+
+        def _on_confirm(result: bool) -> None:
+            if result:
+                plan_store.delete_plan(plan_id)
+                self._plan_sidebar.active_id = ""
+                self._plan_sidebar.refresh_list()
+                self._note("计划已删除。", scroll=True)
+
+        self.app.push_screen(
+            ConfirmModal("删除计划", f"确定删除「{plan_id}」?\n不可恢复。"),
+            callback=_on_confirm,
+        )
+
+    def _do_new_session(self) -> None:
+        if self._session_id:
+            self._auto_save()
+        self.session = Session()
+        self._session_id = ""
+        self._session_name = ""
+        self._follow = True
+        if self.provider is not None:
+            self.agent = AgentLoop(
+                self.config, self.provider, self.session, approve=self._ask_approve
+            )
+        self._session_id = _next_id(_today_dir())
+        self._session_name = "新会话"
+        save_session(self._session_id, self._session_name, self.session.messages)
+        self.call_later(lambda: self.query_one("#chat-log", VerticalScroll).remove_children())
+        self.call_later(self._sidebar.refresh_list)
+        self._note("已新建会话,之前的内容已自动保存。")
+
+    def _do_delete_session(self) -> None:
+        if self._session_id:
+            self._auto_save()
+            from nexforge.store.session_store import delete_session
+            deleted_id = self._session_id
+            delete_session(self._session_id)
+            self._session_id = ""
+            self._session_name = ""
+            self._sidebar.refresh_list()
+            self._note(f"已删除会话:{deleted_id}")
+        else:
+            self._note("当前会话尚未保存,无需删除。", error=True)
+
+    def _do_switch_session(self, bid: str) -> None:
+        if self._sidebar is None:
+            return
+        info = self._sidebar.session_map.get(bid)
+        if info is None:
+            return
+        from nexforge.store.session_store import load_session
+        msgs = load_session(info.path)
+        if msgs is None:
+            self._note(f"无法加载会话:{info.id}", error=True)
+            return
+        if self._session_id:
+            self._auto_save()
+        self.session = Session()
+        self.session.messages = msgs
+        self._session_id = info.id
+        self._session_name = info.name
+        self._follow = True
+        if self.provider is not None:
+            self.agent = AgentLoop(
+                self.config, self.provider, self.session, approve=self._ask_approve
+            )
+        # 清屏 + 渲染历史
+        log = self.query_one("#chat-log", VerticalScroll)
+        log.remove_children()
+        for msg in msgs:
+            role = msg.get("role", "")
+            content = msg.get("content", "")
+            if role == "user" and content:
+                log.mount(UserMessage(content))
+            elif role == "assistant" and content:
+                log.mount(AssistantTurn(initial_content=content))
+        for w in log.query(AssistantTurn):
+            w.finalize_content()
+        self._sidebar.refresh_list()
+        self._note(f"已切换到会话:{info.name}")
+
+    def action_scroll_bottom(self) -> None:
+
+        log = self.query_one("#chat-log", VerticalScroll)
+        log.scroll_end(animate=False)
+
+    def _auto_save(self) -> None:
+        # 用首句更新标题(文件名固定为时间戳,标题可变)
+        first_user = next(
+            (m["content"][:40] for m in self.session.messages if m.get("role") == "user"),
+            "",
+        )
+        if first_user:
+            self._session_name = first_user
+        if not self._session_id:
+            self._session_id = _next_id(_today_dir())
+            self._session_name = self._session_name or "聊天"
+        save_session(self._session_id, self._session_name or "聊天", self.session.messages)
+        if self._sidebar is not None:
+            self.call_later(self._sidebar.refresh_list)
+
+    def action_quit(self) -> None:
+        self.app.exit()
+
+    def action_quit_with_confirm(self) -> None:
+        # AI 工作中 → 停止;空闲 → 退出确认
+        if self._agent_running:
+            self.workers.cancel_group(self, "agent")
+            self._note("⏹ 已停止当前 AI 任务。", scroll=True)
+            return
+        def _on_confirm(result: bool) -> None:
+            if result:
+                self.app.exit()
+        self.app.push_screen(
+            ConfirmModal("退出 NexForgeCLI", "确定要退出吗?\n当前会话已自动保存。", confirm_label="确认退出"),
+            callback=_on_confirm,
+        )
+
+    def _auto_resume(self) -> None:
+        """启动时自动恢复当前项目最近一次会话。"""
+        from nexforge.store.session_store import load_session
+        infos = list_sessions()
+        if not infos:
+            return
+        try:
+            infos.sort(key=lambda s: s.path.stat().st_mtime, reverse=True)
+        except OSError:
+            pass
+        latest = infos[0]
+        msgs = load_session(latest.path)
+        if msgs is None or len(msgs) <= 1:
+            self._session_id = latest.id
+            self._session_name = latest.name
+            return
+        self.session.messages = msgs
+        self._session_id = latest.id
+        self._session_name = latest.name
+        # 渲染历史
+        log = self.query_one("#chat-log", VerticalScroll)
+        for msg in msgs:
+            role = msg.get("role", "")
+            content = msg.get("content", "")
+            if role == "user" and content:
+                log.mount(UserMessage(content))
+            elif role == "assistant" and content:
+                log.mount(AssistantTurn(initial_content=content))
+        # 恢复后渲染 Rich Markdown
+        for w in log.query(AssistantTurn):
+            w.finalize_content()
+        self._set_follow(False)
+        # 刷绿点
+        if self._sidebar:
+            self._sidebar.refresh_list()
+        self._note(f"已恢复会话:{latest.name}({latest.created})")
+
+    # ---- /save 命令回调 ---------------------------------------------------
+    def _save_as(self, name: str) -> None:
+        self._session_name = name
+        if not self._session_id:
+            self._session_id = _next_id(_today_dir())
+        save_session(self._session_id, self._session_name, self.session.messages)
+        if self._sidebar is not None:
+            self.call_later(self._sidebar.refresh_list)
+        self._note(f"已保存会话:{name}")
+
+    async def _ask_approve(self, tool, args: dict) -> bool:
+        """审批回调:review 模式下弹 DiffModal 等 y/n。"""
+        if self.config.ui.mode == "auto":
+            return True
+        preview = tool.preview(args)
+        diff = self._make_diff(tool, args)
+        return await self.app.push_screen_wait(
+            DiffApprovalModal(tool.name, preview, diff)
+        )
+
+    def _make_diff(self, tool, args: dict) -> str:
+        """为写文件工具生成统一 diff 预览。"""
+        import difflib
+        from pathlib import Path
+
+        try:
+            if tool.name == "write_file":
+                path = args.get("path", "")
+                new = args.get("content", "")
+                old = (
+                    Path(path).read_text(encoding="utf-8")
+                    if Path(path).exists()
+                    else ""
+                )
+                return self._unified(old, new, path)
+            if tool.name == "edit_file":
+                path = args.get("path", "")
+                if Path(path).exists():
+                    old = Path(path).read_text(encoding="utf-8")
+                    new = old.replace(
+                        args.get("search", ""), args.get("replace", ""), 1
+                    )
+                    return self._unified(old, new, path)
+            if tool.name == "run_shell":
+                return f"[#22D3EE]$ {args.get('command', '')}[/]"
+            if tool.name == "multi_edit":
+                edits = args.get("edits", [])
+                parts = [
+                    f"[dim]{e.get('path', '')}[/]"
+                    for e in (edits if isinstance(edits, list) else [])
+                ]
+                return "\n".join(parts) or "(无 diff)"
+        except Exception:
+            pass
+        return ""
+
+    @staticmethod
+    def _unified(old: str, new: str, path: str) -> str:
+        import difflib
+
+        lines = list(
+            difflib.unified_diff(
+                old.splitlines(),
+                new.splitlines(),
+                fromfile=path,
+                tofile=path,
+                lineterm="",
+                n=2,
+            )
+        )[:40]
+        out = []
+        for ln in lines:
+            if ln.startswith("+") and not ln.startswith("+++"):
+                out.append(f"[green]{ln}[/]")
+            elif ln.startswith("-") and not ln.startswith("---"):
+                out.append(f"[red]{ln}[/]")
+            else:
+                out.append(f"[dim]{ln}[/]")
+        return "\n".join(out)