mindcode 0.2.0__py3-none-any.whl

mindcode/cli/shell/repl.py

@@ -0,0 +1,597 @@
+"""Shell 类 — mindcode 全屏 TUI 的队列与 runtime 主循环。
+
+Prompt Toolkit 的固定输入框只负责收集文本；process_loop 继续按原有顺序
+处理队列中的 slash 命令和 agent turn。
+"""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from mindagent.core import (
+    ActionType,
+    AgentSession,
+    AgentRuntime,
+    LocalConversationStore,
+    SessionEnvironment,
+    SessionEventType,
+    SessionPolicy,
+)
+from ...config import (
+    CONFIG_FILE,
+    MindcodeConfig,
+    SESSIONS_DIR,
+    load_config,
+    save_config,
+)
+from ...approval import make_shell_approval
+from ...policy import ApprovalMode, approval_mode_label
+from ...render import RichRenderer
+from ...runtime import build_master_worker_system, build_runtime
+from ...subagents import MasterWorkerSystem
+from .._shared import console
+from .completion import MindcodeCompleter
+from .slash import handle_slash_command
+from .startup import build_welcome_banner
+from .tui import MindcodeTui, Transcript, redirect_console_output
+
+
+@dataclass
+class _SessionErrorResult:
+    """Minimal result shape used when the Session actor rejects a command."""
+
+    run_id: str
+    error: str
+    final_answer: str | None = None
+    error_info: Any | None = None
+
+
+@dataclass
+class ShellState:
+    """Mutable state shared with slash command handlers."""
+
+    config_path: Path
+    config: MindcodeConfig
+    active_provider: str
+    active_model: str
+    runtime: AgentRuntime | None
+    subagent_system: MasterWorkerSystem | None
+    renderer: RichRenderer
+    store: LocalConversationStore
+    workspace: Path
+    session_id: str
+    approve_mode: ApprovalMode
+    stream: bool
+    subagents: bool = False
+    session: AgentSession | None = None
+    max_steps: int = 50
+    step_timeout_s: float | None = 300.0
+    total_timeout_s: float | None = 1800.0
+    history: list[dict[str, Any]] = field(default_factory=list)
+    last_run_id: str | None = None
+
+    async def rebuild_runtime(self) -> None:
+        provider = self.config.providers[self.active_provider]
+        approval = make_shell_approval(
+            lambda: getattr(self, "choose_option", None)
+        )
+        if self.subagents:
+            replacement = build_master_worker_system(
+                self.workspace,
+                provider_config=provider,
+                approve_mode=self.approve_mode,
+                model=self.active_model or None,
+                stream=self.stream,
+                event_handler=self.renderer,
+                max_steps=self.max_steps,
+                step_timeout_s=self.step_timeout_s,
+                total_timeout_s=self.total_timeout_s,
+                approval_callback=approval,
+            )
+        else:
+            replacement = build_runtime(
+                self.workspace,
+                provider_config=provider,
+                approve_mode=self.approve_mode,
+                model=self.active_model or None,
+                stream=self.stream,
+                event_handler=self.renderer,
+                max_steps=self.max_steps,
+                step_timeout_s=self.step_timeout_s,
+                total_timeout_s=self.total_timeout_s,
+                approval_callback=approval,
+            )
+        try:
+            await self.close()
+        except Exception:
+            if isinstance(replacement, MasterWorkerSystem):
+                await replacement.close()
+            else:
+                await replacement.close(close_dependencies=True)
+            raise
+        if isinstance(replacement, MasterWorkerSystem):
+            self.subagent_system = replacement
+            self.runtime = None
+            self.session = None
+        else:
+            self.runtime = replacement
+            self.subagent_system = None
+            self.session = self._create_session(replacement)
+
+    def _create_session(self, runtime: AgentRuntime) -> AgentSession:
+        return runtime.create_session(
+            session_id=self.session_id,
+            environment=SessionEnvironment(
+                workspace_root=self.workspace,
+                working_directory=self.workspace,
+            ),
+            policy=SessionPolicy(
+                allow_write=True,
+                allow_dangerous=True,
+                max_parallel_actions=1,
+            ),
+            conversation_store=self.store,
+        )
+
+    async def close(self) -> None:
+        if self.subagent_system is not None:
+            await self.subagent_system.close()
+        elif self.runtime is not None:
+            await self.runtime.close(close_dependencies=True)
+
+    def _save_config(self) -> None:
+        save_config(self.config)
+
+
+class Shell:
+    """Mindcode 全屏终端交互会话。"""
+
+    def __init__(
+        self,
+        workspace: Path,
+        *,
+        approve_mode: ApprovalMode,
+        provider_name: str | None,
+        model: str | None,
+        session_id: str | None,
+        resume: str | None,
+        stream: bool,
+        subagents: bool = False,
+        max_steps: int = 50,
+        step_timeout_s: float | None = 300.0,
+        total_timeout_s: float | None = 1800.0,
+    ):
+        self.workspace = workspace
+        self.approve_mode = approve_mode
+        self.stream = stream
+        self.resume_id = resume
+        self.explicit_session_id = session_id
+
+        self.config = load_config(CONFIG_FILE)
+        active_provider = provider_name or self.config.default_provider
+        if not active_provider or active_provider not in self.config.providers:
+            raise ValueError(
+                f"无效 provider: {active_provider}；可用: "
+                f"{', '.join(self.config.providers)}"
+            )
+        provider = self.config.providers[active_provider]
+        active_model = (
+            model
+            or provider.default_model
+            or (provider.models[0] if provider.models else "")
+        )
+
+        self.renderer = RichRenderer(console=console)
+        # TUI 在 run() 才创建，chooser 必须运行时动态读取；
+        # state 尚不存在，闭包延迟到审批调用时才求值。
+        approval = make_shell_approval(
+            lambda: getattr(self.state, "choose_option", None)
+        )
+        if subagents:
+            self.runtime = None
+            self.subagent_system = build_master_worker_system(
+                workspace,
+                provider_config=provider,
+                approve_mode=approve_mode,
+                model=active_model or None,
+                stream=stream,
+                event_handler=self.renderer,
+                max_steps=max_steps,
+                step_timeout_s=step_timeout_s,
+                total_timeout_s=total_timeout_s,
+                approval_callback=approval,
+            )
+        else:
+            self.runtime = build_runtime(
+                workspace,
+                provider_config=provider,
+                approve_mode=approve_mode,
+                model=active_model or None,
+                stream=stream,
+                event_handler=self.renderer,
+                max_steps=max_steps,
+                step_timeout_s=step_timeout_s,
+                total_timeout_s=total_timeout_s,
+                approval_callback=approval,
+            )
+            self.subagent_system = None
+
+        self.store = LocalConversationStore(SESSIONS_DIR)
+
+        if resume:
+            self.session_id = resume
+            self.history = self.store.load(resume)
+            if not self.history:
+                console.print(
+                    f"[yellow]警告:[/yellow] session [cyan]{resume}[/cyan]"
+                    " 没有可恢复的历史"
+                )
+        else:
+            self.session_id = (
+                session_id or f"sess-{int(time.time())}"
+            )
+            self.history = []
+
+        self.state = ShellState(
+            config_path=CONFIG_FILE,
+            config=self.config,
+            active_provider=active_provider,
+            active_model=active_model,
+            runtime=self.runtime,
+            subagent_system=self.subagent_system,
+            renderer=self.renderer,
+            store=self.store,
+            workspace=workspace,
+            session_id=self.session_id,
+            approve_mode=approve_mode,
+            stream=stream,
+            subagents=subagents,
+            max_steps=max_steps,
+            step_timeout_s=step_timeout_s,
+            total_timeout_s=total_timeout_s,
+            session=(
+                self.runtime.create_session(
+                    session_id=self.session_id,
+                    environment=SessionEnvironment(
+                        workspace_root=workspace,
+                        working_directory=workspace,
+                    ),
+                    policy=SessionPolicy(
+                        allow_write=True,
+                        allow_dangerous=True,
+                        max_parallel_actions=1,
+                    ),
+                    conversation_store=self.store,
+                )
+                if self.runtime is not None
+                else None
+            ),
+            history=self.history,
+        )
+        # Slash completion remains the same; TUI only changes its visual host.
+        self.state.completer = MindcodeCompleter(self.state)
+
+        # 并发队列 + 忙标记
+        self._queue: asyncio.Queue[str | None] = asyncio.Queue()
+        self._busy: bool = False
+        self._tui: MindcodeTui | None = None
+
+    async def run(self) -> int:
+        self._tui = MindcodeTui(
+            self.state,
+            Transcript(),
+            on_submit=self._submit_from_tui,
+            on_exit=self._request_exit,
+            status_provider=self._status_text,
+        )
+        self.renderer.attach_transcript(self._tui.transcript)
+        self.state.choose_option = self._tui.choose
+        self._print_banner()
+        process_task = asyncio.create_task(self._process_loop())
+        tui_task = asyncio.create_task(self._tui.run())
+        try:
+            with redirect_console_output(self._tui.transcript):
+                await process_task
+        finally:
+            self._tui.exit()
+            try:
+                await tui_task
+            except asyncio.CancelledError:
+                pass
+            self.renderer.detach_transcript()
+            await self.state.close()
+        return 0
+
+    async def _submit_from_tui(self, text: str) -> None:
+        """Keep the existing queue semantics behind the new fixed composer."""
+        text = text.strip()
+        if not text:
+            return
+        if not text.startswith("/") and self._tui is not None:
+            # Echo immediately, including while a previous agent turn is
+            # running, so queued work remains visible to the user.
+            self._tui.add_user_message(text)
+        await self._queue.put(text)
+        if self._busy and self._tui is not None:
+            self._tui.transcript.add_system(
+                f"已加入队列（第 {self._queue.qsize()} 项）"
+            )
+
+    async def _request_exit(self) -> None:
+        await self._queue.put(None)
+
+    async def _process_loop(self) -> None:
+        """从队列取消息，依次处理。None 表示退出。"""
+        while True:
+            text = await self._queue.get()
+            if text is None:
+                console.print("[dim]bye[/dim]")
+                return
+            self._set_busy(True)
+            try:
+                signal = await self._dispatch(text)
+                if signal == "exit":
+                    console.print("[dim]bye[/dim]")
+                    return
+            except KeyboardInterrupt:
+                console.print("\n[yellow]interrupted[/yellow]")
+            finally:
+                self._set_busy(False)
+                self.store.save(self.state.session_id, self.state.history)
+
+    async def _dispatch(self, text: str) -> str | None:
+        """分发：slash 命令 vs agent turn。"""
+        if text.startswith("/"):
+            return await handle_slash_command(text, self.state)
+        await self._run_turn(text)
+        return None
+
+    def _print_banner(self) -> None:
+        provider = self.config.providers.get(self.state.active_provider)
+        if self._tui is not None:
+            self._tui.transcript.add_system(
+                "已就绪。输入消息开始对话；/help 查看命令；/exit 退出。"
+            )
+            if self.state.history:
+                self._tui.transcript.add_system(
+                    f"已恢复 {len(self.state.history)} 条历史消息。"
+                )
+            if not provider or not provider.api_key:
+                self._tui.transcript.add_system(
+                    "提示：当前 provider 还未配置 API key。"
+                )
+            return
+        console.print(
+            build_welcome_banner(
+                model=self.state.active_model,
+                provider=self.state.active_provider,
+                workspace=str(self.workspace),
+                session_id=self.state.session_id,
+                approve_mode=approval_mode_label(self.state.approve_mode),
+                api_key_set=bool(provider and provider.api_key),
+            )
+        )
+        if self.state.history:
+            console.print(
+                f"  [dim]resumed {len(self.state.history)} messages[/dim]"
+            )
+
+    async def _run_turn(self, user_input: str) -> None:
+        self.renderer.reset()
+        if self.state.subagent_system is not None:
+            result = await self.state.subagent_system.run(
+                user_input,
+                messages=self.state.history,
+                session_environment=SessionEnvironment(
+                    workspace_root=self.workspace,
+                ),
+                session_policy=SessionPolicy(
+                    allowed_action_types=frozenset({ActionType.AGENT}),
+                    allow_write=False,
+                    allow_dangerous=False,
+                    max_parallel_actions=1,
+                ),
+            )
+            self.state.last_run_id = result.run_id
+            self.state.history.extend(
+                [
+                    {"role": "user", "content": user_input},
+                    {
+                        "role": "assistant",
+                        "content": result.final_answer or result.error or "",
+                    },
+                ]
+            )
+        else:
+            result = await self._run_session_turn(user_input)
+
+        if getattr(self, "_tui", None) is None:
+            console.print(f"[dim]run_id={result.run_id}[/dim]")
+
+        if result.error:
+            error_info = getattr(result, "error_info", None)
+            recoverable = (
+                error_info is not None
+                and getattr(error_info, "recoverable", False)
+            )
+            tag = "[yellow]pause›[/yellow]" if recoverable else "[red]error›[/red]"
+            console.print(f"\n{tag} {result.error}")
+            if not recoverable:
+                return
+            console.print("[dim]已保存进度，发送新消息可继续[/dim]")
+            return
+
+        self.renderer._flush_stream()
+        if not self.renderer._did_stream and result.final_answer:
+            render_final_answer = getattr(
+                self.renderer, "render_final_answer", None
+            )
+            if render_final_answer is not None:
+                render_final_answer(result.final_answer)
+            else:
+                console.print(
+                    f"\n[bold cyan]answer›[/bold cyan] {result.final_answer}"
+                )
+
+    async def _run_session_turn(self, user_input: str) -> Any:
+        """Run through AgentSession and keep the legacy history view synced."""
+        session = await self._ensure_session()
+        checkpoint = session.pending_checkpoint
+        if checkpoint is None:
+            command_id = await session.submit_run(user_input)
+        else:
+            command_id = await session.continue_run(
+                checkpoint.checkpoint_id,
+                user_input=user_input,
+            )
+        while True:
+            event = await session.next_event()
+            if event.event_type == SessionEventType.RUN_ACCEPTED:
+                self.state.last_run_id = event.run_id
+                continue
+            if event.event_type == SessionEventType.APPROVAL_REQUIRED:
+                # 问答与审批暂共享 WAITING 通道：仅提示，不阻塞，继续等后续事件。
+                # 审批走 session.approve_run/reject_run（见 approve_current_run/
+                # reject_current_run），问答走 submit_user_input。
+                console.print(
+                    f"[yellow]等待审批/输入，run_id={event.run_id}[/yellow]"
+                )
+                continue
+            if event.event_type == SessionEventType.APPROVAL_DECIDED:
+                decision = event.payload.get("decision", "decided")
+                console.print(
+                    f"[dim]审批已决策({decision})，run_id={event.run_id}，"
+                    "等待 run 完成[/dim]"
+                )
+                continue
+            if (
+                event.event_type == SessionEventType.RUN_COMPLETED
+                and event.correlation_id == command_id
+            ):
+                result = event.payload.get("result")
+                if result is None:
+                    reason = event.payload.get("error", "session run failed")
+                    result = _SessionErrorResult(
+                        run_id=event.run_id or self.state.last_run_id or "",
+                        error=str(reason),
+                    )
+                self.state.history[:] = session.messages
+                return result
+            if (
+                event.event_type == SessionEventType.COMMAND_REJECTED
+                and event.correlation_id == command_id
+            ):
+                reason = event.payload.get("reason", "session command rejected")
+                return _SessionErrorResult(
+                    run_id=event.run_id or self.state.last_run_id or "",
+                    error=str(reason),
+                )
+
+    async def approve_current_run(self, comment: str = "approved") -> str:
+        """审批通过当前 run：透调 session.approve_run（REPL 便捷调用点）。"""
+        session = self.state.session
+        if session is None or not self.state.last_run_id:
+            raise RuntimeError("当前没有可审批的 run")
+        return await session.approve_run(self.state.last_run_id, comment)
+
+    async def reject_current_run(self, reason: str = "rejected") -> str:
+        """审批拒绝当前 run：透调 session.reject_run（REPL 便捷调用点）。"""
+        session = self.state.session
+        if session is None or not self.state.last_run_id:
+            raise RuntimeError("当前没有可拒绝的 run")
+        return await session.reject_run(self.state.last_run_id, reason)
+
+    async def _ensure_session(self) -> AgentSession:
+        """Reconcile slash-command edits before submitting a new run."""
+        runtime = self.state.runtime
+        if runtime is None:
+            raise RuntimeError("当前 shell 没有可用 runtime")
+        session = self.state.session
+        if session is None:
+            self.state.session = self._new_session(runtime)
+            return self.state.session
+        if session.messages == self.state.history:
+            return session
+
+        # Slash commands mutate the compatibility history list. Persist that
+        # explicit product-layer edit, then replace the actor so its next run
+        # loads exactly the same transcript from ConversationStore.
+        self.state.store.save(self.state.session_id, self.state.history)
+        await runtime.close_session(session.session_id)
+        self.state.session = self._new_session(runtime)
+        return self.state.session
+
+    def _new_session(self, runtime: AgentRuntime) -> AgentSession:
+        return runtime.create_session(
+            session_id=self.state.session_id,
+            environment=SessionEnvironment(
+                workspace_root=self.state.workspace,
+                working_directory=self.state.workspace,
+            ),
+            policy=SessionPolicy(
+                allow_write=True,
+                allow_dangerous=True,
+                max_parallel_actions=1,
+            ),
+            conversation_store=self.state.store,
+        )
+
+    def _status_text(self) -> str:
+        return (
+            f"{self.state.active_provider}/{self.state.active_model}  ·  "
+            f"{approval_mode_label(self.state.approve_mode)}  ·  "
+            f"{self.state.workspace}"
+        )
+
+    def _set_busy(self, busy: bool) -> None:
+        self._busy = busy
+        if self._tui is not None:
+            self._tui.set_working(busy)
+
+
+def run_shell(
+    workspace: Path,
+    *,
+    approve_mode: ApprovalMode,
+    provider_name: str | None,
+    model: str | None,
+    session_id: str | None,
+    resume: str | None,
+    stream: bool,
+    subagents: bool = False,
+    one_shot_prompt: str | None = None,
+    max_steps: int = 50,
+    step_timeout_s: float | None = 300.0,
+    total_timeout_s: float | None = 1800.0,
+) -> int:
+    """Synchronous entry: build Shell and run it (or one-shot)."""
+    shell = Shell(
+        workspace,
+        approve_mode=approve_mode,
+        provider_name=provider_name,
+        model=model,
+        session_id=session_id,
+        resume=resume,
+        stream=stream,
+        subagents=subagents,
+        max_steps=max_steps,
+        step_timeout_s=step_timeout_s,
+        total_timeout_s=total_timeout_s,
+    )
+
+    if one_shot_prompt:
+        return asyncio.run(_one_shot(shell, one_shot_prompt))
+    return asyncio.run(shell.run())
+
+
+async def _one_shot(shell: Shell, prompt: str) -> int:
+    try:
+        await shell._run_turn(prompt)
+        shell.store.save(shell.state.session_id, shell.state.history)
+        return 0
+    finally:
+        await shell.state.close()