mycode-coding-agent 0.1.0__py3-none-any.whl

mycode/presentation/cli/mcp_trust.py

@@ -0,0 +1,61 @@
+"""Terminal presentation for the application MCP trust contract."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from mycode.mcp.trust import MCPTrustRequest, MCPTrustWarning
+
+
+class TerminalMCPTrustConfirmer:
+    def __init__(
+        self,
+        input_func: Callable[[str], str] = input,
+        output_func: Callable[[str], None] = print,
+    ) -> None:
+        self.input_func = input_func
+        self.output_func = output_func
+
+    def confirm(self, request: MCPTrustRequest) -> bool:
+        self._show_request(request)
+        try:
+            approved = self.input_func(
+                "MCP trust> 是否信任并启用这些项目级 MCP？[y/N] "
+            ).strip().lower() in {"y", "yes"}
+        except EOFError:
+            approved = False
+
+        if not approved:
+            self.output_func("MCP trust> 未启用项目级 MCP")
+        return approved
+
+    def report_warning(self, warning: MCPTrustWarning) -> None:
+        if warning.code == "invalid_trust_store":
+            self.output_func(
+                "MCP trust> 警告：信任状态文件无效；"
+                "项目级 MCP 将按未信任处理"
+            )
+        elif warning.code == "persistence_failed":
+            self.output_func(
+                "MCP trust> 警告：信任状态未能保存；"
+                "本次仍会启用，下次将再次询问"
+            )
+
+    def _show_request(self, request: MCPTrustRequest) -> None:
+        self.output_func("MCP trust> 项目配置请求启用以下 MCP Server：")
+        for server in request.servers:
+            self.output_func("")
+            self.output_func(f"server> {server.alias!r}")
+            self.output_func(f"transport> {server.transport}")
+            if server.transport == "stdio":
+                self.output_func(f"command> {server.command!r}")
+                self.output_func(f"args> {list(server.args)!r}")
+                if server.env_keys:
+                    self.output_func(f"env keys> {list(server.env_keys)!r}")
+                continue
+
+            self.output_func(f"url template> {server.url_template!r}")
+            if server.destination is not None:
+                self.output_func(f"destination> {server.destination!r}")
+            if server.header_keys:
+                self.output_func(f"header keys> {list(server.header_keys)!r}")

mycode/presentation/cli/presenter.py

@@ -0,0 +1,320 @@
+from collections import deque
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import Literal
+
+from mycode.agent.events import AgentEvent, AgentToolCall
+from mycode.event_format import summarize_event_content, summarize_tool_arguments
+
+
+CliDisplayMode = Literal["normal", "verbose", "debug"]
+
+
+READ_ONLY_ACTIVITY_TOOLS = {
+    "glob",
+    "grep",
+    "inspect_changes",
+    "list_memories",
+    "read_artifact",
+    "read_file",
+}
+
+
+@dataclass
+class CliPresenter:
+    output: Callable[[str], None]
+    mode: CliDisplayMode = "normal"
+    _read_only_calls: list[AgentToolCall] = field(default_factory=list, init=False)
+    _pending_result_tools: deque[str] = field(default_factory=deque, init=False)
+    _continue_after_error: bool = field(default=False, init=False)
+
+    def flush(self) -> None:
+        if not self._read_only_calls:
+            return
+        self.output(_summarize_read_only_activity(self._read_only_calls))
+        self._read_only_calls.clear()
+
+    def show_agent_event(self, event: AgentEvent) -> None:
+        if event.type == "turn":
+            if event.turn_number is None or event.max_turns is None:
+                return
+            label = "轮次" if self.mode == "normal" else "turn"
+            self.output(f"{label}> {event.turn_number}/{event.max_turns}")
+            if event.content:
+                notice_label = "提醒" if self.mode == "normal" else "turn_notice"
+                self.output(f"{notice_label}> {event.content}")
+            return
+
+        if event.type == "context":
+            if self.mode != "normal":
+                self.output(f"context> {event.content}")
+            return
+
+        if event.type == "progress":
+            if self.mode == "debug" and event.progress is not None:
+                progress = event.progress
+                self.output(
+                    "progress> "
+                    f"stagnation_turns={progress.stagnation_turns} "
+                    f"same_tool_repeat={progress.same_tool_repeat} "
+                    f"same_result_repeat={progress.same_result_repeat} "
+                    f"resource_repeat={progress.resource_repeat} "
+                    f"convergence_guided={progress.convergence_guided} "
+                    f"reason={progress.reason}"
+                )
+            return
+
+        if event.type == "artifact_warning":
+            self.flush()
+            if self.mode == "normal":
+                self.output(f"警告> 工具结果归档异常：{event.content}")
+            else:
+                self.output(f"artifact> warning: {event.content}")
+            return
+
+        if event.type == "model_retry" and event.model_retry is not None:
+            self.flush()
+            retry = event.model_retry
+            if self.mode == "normal":
+                self.output(
+                    "重试> 模型连接异常，"
+                    f"{retry.delay_seconds:.1f} 秒后重试当前模型轮次"
+                    f"（{retry.attempt}/{retry.max_retries}）"
+                )
+            else:
+                self.output(
+                    "model_retry> "
+                    f"call_kind={retry.call_kind} "
+                    f"attempt={retry.attempt}/{retry.max_retries} "
+                    f"error_type={retry.error_type} "
+                    f"error_code={retry.error_code} "
+                    f"retryable={retry.retryable} "
+                    f"delay_seconds={retry.delay_seconds:.1f} "
+                    f"stream_started={retry.stream_started} "
+                    f"partial_output_chars={retry.partial_output_chars}"
+                )
+            return
+
+        if event.type == "tool_call" and event.tool_call is not None:
+            self._pending_result_tools.append(event.tool_call.name)
+            if self.mode == "normal":
+                if self._continue_after_error:
+                    self.flush()
+                    self.output("活动> 上一步失败，正在尝试其他方式")
+                    self._continue_after_error = False
+                if event.tool_call.name in READ_ONLY_ACTIVITY_TOOLS:
+                    self._read_only_calls.append(event.tool_call)
+                    return
+                self.flush()
+                if event.tool_call.name != "delegate_task":
+                    self.output(_describe_activity(event.tool_call))
+                return
+            argument_summary = summarize_tool_arguments(
+                event.tool_call.name,
+                event.tool_call.arguments,
+            )
+            self.output(
+                f"tool_call> {event.tool_call.name}"
+                f"({argument_summary})"
+            )
+            return
+
+        if event.type == "tool_result" and event.tool_result is not None:
+            self.flush()
+            result = event.tool_result
+            status = "ok" if result.ok else "error"
+            tool_name = (
+                self._pending_result_tools.popleft()
+                if self._pending_result_tools
+                else str(result.metadata.get("tool_name", "工具"))
+            )
+            if result.metadata.get("tool_name") == "delegate_task":
+                metadata = result.metadata
+                child_status = metadata.get("child_status", status)
+                if self.mode == "normal" and result.ok and child_status == "completed":
+                    return
+                if self.mode == "normal":
+                    reason = metadata.get(
+                        "child_stop_reason",
+                        metadata.get("reason", "未知原因"),
+                    )
+                    self.output(
+                        f"警告> SubAgent 未完成：角色={metadata.get('role', 'unknown')}，"
+                        f"状态={child_status}，原因={reason}"
+                    )
+                    self._continue_after_error = True
+                    return
+                details = [
+                    f"role={metadata.get('role', 'unknown')}",
+                    f"status={child_status}",
+                    "stop="
+                    f"{metadata.get('child_stop_reason', metadata.get('reason', 'unknown'))}",
+                ]
+                self.output(f"tool_result> {status}: subagent " + " ".join(details))
+                return
+            if self.mode == "normal" and result.ok:
+                return
+            summary = summarize_event_content(
+                result.content if result.ok else result.error
+            )
+            if self.mode == "normal":
+                self.output(
+                    f"警告> {_tool_display_name(tool_name)}失败："
+                    f"{_localize_error(summary)}"
+                )
+                self._continue_after_error = True
+                return
+            self.output(f"tool_result> {status}: {summary}")
+            return
+
+        if event.type == "error":
+            self.flush()
+            message = _localize_error(event.error or event.content)
+            if self.mode == "normal":
+                self.output(f"错误> {message}")
+            else:
+                self.output(f"error> {message}")
+            return
+
+        if event.type == "stop":
+            self.flush()
+            if event.stop_reason == "max_turns":
+                message = event.content or (
+                    "本轮已达到步骤上限，未能生成最终答案。"
+                )
+                self.output(f"警告> {message}")
+                self.output(
+                    "提示> 当前进度已保存；如需继续，直接输入“继续”。"
+                )
+                if self.mode == "debug":
+                    self.output("stop> max_turns")
+                return
+            if self.mode == "normal":
+                stop_message = _normal_stop_message(event.stop_reason)
+                if stop_message is not None:
+                    self.output(stop_message)
+                return
+            if self.mode == "debug" or event.stop_reason != "final_answer":
+                self.output(f"stop> {event.stop_reason}")
+
+
+def _summarize_read_only_activity(calls: list[AgentToolCall]) -> str:
+    if len(calls) == 1:
+        return _describe_activity(calls[0])
+    if all(call.name == "read_file" for call in calls):
+        targets = [_read_file_target(call) for call in calls]
+        return f"活动> 正在读取 {len(targets)} 个文件：{', '.join(targets)}"
+    if all(call.name == "read_artifact" for call in calls):
+        return f"活动> 正在读取 {len(calls)} 份已保存的工具结果"
+    if all(call.name == "grep" for call in calls):
+        return f"活动> 正在执行 {len(calls)} 次代码搜索"
+    counts = {name: 0 for name in READ_ONLY_ACTIVITY_TOOLS}
+    for call in calls:
+        counts[call.name] += 1
+    summaries = []
+    labels = {
+        "read_file": "读取 {count} 个文件",
+        "grep": "搜索代码 {count} 次",
+        "glob": "查找文件 {count} 次",
+        "read_artifact": "读取 {count} 份已保存的工具结果",
+        "inspect_changes": "检查代码变更 {count} 次",
+        "list_memories": "读取长期记忆 {count} 次",
+    }
+    for name in (
+        "read_file",
+        "grep",
+        "glob",
+        "read_artifact",
+        "inspect_changes",
+        "list_memories",
+    ):
+        if counts[name] > 0:
+            summaries.append(labels[name].format(count=counts[name]))
+    return "活动> 正在进行只读分析：" + "、".join(summaries)
+
+
+def _describe_activity(call: AgentToolCall) -> str:
+    arguments = call.arguments
+    if call.name == "read_file":
+        path = arguments.get("path", "未知文件")
+        start_line = arguments.get("start_line")
+        if isinstance(start_line, int) and start_line > 1:
+            return f"活动> 正在继续读取 {path}（从第 {start_line} 行开始）"
+        return f"活动> 正在读取文件：{path}"
+    if call.name == "read_artifact":
+        offset = arguments.get("offset_chars")
+        if isinstance(offset, int) and offset > 0:
+            return (
+                "活动> 正在继续读取已保存的工具结果"
+                f"（从第 {offset} 个字符开始）"
+            )
+        return "活动> 正在读取已保存的工具结果"
+    if call.name == "glob":
+        return f"活动> 正在查找文件：{arguments.get('pattern', '未知范围')}"
+    if call.name == "grep":
+        return (
+            "活动> 正在搜索代码："
+            f"{arguments.get('path_pattern', '工作区内的文件')}"
+        )
+    if call.name == "inspect_changes":
+        return "活动> 正在检查代码变更"
+    if call.name == "list_memories":
+        return "活动> 正在读取长期记忆"
+    activity_names = {
+        "delete_memory": "正在删除长期记忆",
+        "edit_file": "正在编辑文件",
+        "run_command": "正在运行命令",
+        "save_memory": "正在保存长期记忆",
+        "write_file": "正在写入文件",
+    }
+    description = activity_names.get(call.name, f"正在执行 {call.name}")
+    return f"活动> {description}"
+
+
+def _read_file_target(call: AgentToolCall) -> str:
+    path = str(call.arguments.get("path", "未知文件"))
+    start_line = call.arguments.get("start_line")
+    if isinstance(start_line, int) and start_line > 1:
+        return f"{path}（从第 {start_line} 行继续）"
+    return path
+
+
+def _tool_display_name(name: str) -> str:
+    names = {
+        "glob": "查找文件",
+        "grep": "搜索代码",
+        "read_artifact": "读取已保存的工具结果",
+        "read_file": "读取文件",
+    }
+    return names.get(name, name)
+
+
+def _localize_error(message: str) -> str:
+    translations = {
+        "File not found: ": "未找到文件：",
+        "Directory not found: ": "未找到目录：",
+        "Model streaming failed: ": "模型流式请求失败：",
+        "Model request failed: ": "模型请求失败：",
+    }
+    for prefix, translated in translations.items():
+        if message.startswith(prefix):
+            return translated + message[len(prefix) :]
+    return message
+
+
+def _normal_stop_message(stop_reason: str | None) -> str | None:
+    messages = {
+        "context_overflow": "错误> 当前上下文超过模型可用范围，本轮无法继续。",
+        "model_error": "提示> 本轮因模型调用错误而结束。",
+        "repeated_tool_call": "警告> 模型连续重复了相同的工具调用，本轮已停止。",
+        "tool_error": "警告> 本轮因工具执行错误而停止。",
+    }
+    return messages.get(stop_reason)
+
+
+__all__ = [
+    "CliDisplayMode",
+    "CliPresenter",
+    "summarize_event_content",
+    "summarize_tool_arguments",
+]

mycode/presentation/cli/session_menu.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from mycode.application.sessions import (
+    SessionStartRequest,
+    delete_project_session,
+    list_project_sessions,
+)
+from mycode.persistence.session_store import (
+    SessionRecord,
+    SessionStore,
+    SessionStoreError,
+)
+from mycode.project import ProjectIdentity
+
+
+def select_session_request(
+    store: SessionStore,
+    project: ProjectIdentity,
+    *,
+    input_func: Callable[[str], str] = input,
+    output_func: Callable[[str], None] = print,
+) -> SessionStartRequest | None:
+    sessions = list_project_sessions(store, project)
+    output_func(f"session> 项目 {project.workspace_root}")
+    if not sessions:
+        output_func("session> 没有历史会话，正在创建新会话")
+        return SessionStartRequest(mode="new")
+
+    while True:
+        if sessions:
+            output_func("session> 请选择历史会话，或管理已有会话")
+            _output_numbered_sessions(sessions, output_func)
+        else:
+            output_func("session> 当前没有历史会话")
+        output_func("session> [N] 创建新会话")
+        if sessions:
+            output_func("session> [D] 永久删除会话")
+        output_func("session> [Q] 退出")
+
+        try:
+            answer = input_func("session> ").strip()
+        except EOFError:
+            output_func("")
+            return None
+        normalized = answer.casefold()
+        if normalized in {"n", "new"}:
+            return SessionStartRequest(mode="new")
+        if normalized in {"d", "delete"} and sessions:
+            _delete_session_interactively(
+                store,
+                project,
+                sessions,
+                input_func=input_func,
+                output_func=output_func,
+            )
+            sessions = list_project_sessions(store, project)
+            continue
+        if normalized in {"q", "quit"}:
+            return None
+        if answer.isdigit():
+            index = int(answer)
+            if 1 <= index <= len(sessions):
+                selected = sessions[index - 1]
+                return SessionStartRequest(mode="resume", session_id=selected.id)
+        output_func("session> 选择无效，请重新输入")
+
+
+def _output_numbered_sessions(
+    sessions: list[SessionRecord],
+    output_func: Callable[[str], None],
+) -> None:
+    for index, session in enumerate(sessions, start=1):
+        output_func(
+            f"session> [{index}] {session.title} "
+            f"({_session_status_label(session.status)}, {session.id[:8]})"
+        )
+
+
+def _delete_session_interactively(
+    store: SessionStore,
+    project: ProjectIdentity,
+    sessions: list[SessionRecord],
+    *,
+    input_func: Callable[[str], str],
+    output_func: Callable[[str], None],
+) -> None:
+    output_func("session> 请选择要永久删除的会话")
+    _output_numbered_sessions(sessions, output_func)
+    output_func("session> [Q] 取消删除")
+
+    target: SessionRecord | None = None
+    while target is None:
+        try:
+            answer = input_func("session delete> ").strip()
+        except EOFError:
+            output_func("")
+            output_func("session> 已取消删除")
+            return
+        if answer.casefold() in {"q", "quit", "cancel"}:
+            output_func("session> 已取消删除")
+            return
+        if answer.isdigit():
+            index = int(answer)
+            if 1 <= index <= len(sessions):
+                target = sessions[index - 1]
+                break
+        output_func("session> 删除选项无效，请重新输入")
+
+    confirmation = f"DELETE {target.id}"
+    output_func(
+        f"session> 将永久删除 {target.title} "
+        f"({_session_status_label(target.status)}, {target.id})"
+    )
+    output_func(
+        "session> 这会删除该会话的消息、工具调用、Compact 状态、"
+        "SubAgent 记录和 artifact"
+    )
+    try:
+        answer = input_func(f"session> 输入 {confirmation} 进行确认：").strip()
+    except EOFError:
+        output_func("")
+        output_func("session> 已取消删除")
+        return
+    if answer != confirmation:
+        output_func("session> 已取消删除：确认文本不匹配")
+        return
+
+    try:
+        removed = delete_project_session(store, project, target.id)
+    except SessionStoreError as error:
+        output_func(f"session> 当前无法删除：{error}")
+        return
+    if removed:
+        output_func(f"session> 已永久删除 {target.id}：{target.title}")
+    else:
+        output_func(f"session> 会话此前已经删除：{target.id}")
+
+
+def _session_status_label(status: str) -> str:
+    return {
+        "active": "进行中",
+        "closed": "已关闭",
+        "interrupted": "已中断",
+    }.get(status, status)

mycode/presentation/cli/subagent_observer.py

@@ -0,0 +1,124 @@
+from collections.abc import Callable
+from dataclasses import dataclass
+from datetime import datetime
+
+from mycode.presentation.cli.presenter import CliDisplayMode
+from mycode.subagents.audit import SubAgentToolAudit
+from mycode.subagents.contracts import SubAgentTask
+from mycode.subagents.lifecycle import SubAgentStateTransition
+from mycode.subagents.runtime import SubAgentExecution
+from mycode.subagents.snapshots import SubAgentSnapshotMetadata
+
+
+CLI_SUBAGENT_SUMMARY_CHARS = 160
+
+
+@dataclass(frozen=True)
+class CliSubAgentObserver:
+    output: Callable[[str], None]
+    mode: CliDisplayMode = "normal"
+
+    def on_state(
+        self,
+        task: SubAgentTask,
+        transition: SubAgentStateTransition,
+    ) -> None:
+        run = transition.run_id[:8]
+        if transition.state == "running" and transition.reason == "run_started":
+            if self.mode == "normal":
+                self.output(f"activity> {transition.role.capitalize()} started")
+                return
+            self.output(
+                f"subagent> start role={transition.role} run={run} "
+                f"objective_chars={len(task.objective)} "
+                f"context_chars={len(task.context)} scope_paths={len(task.scope_paths)}"
+            )
+            return
+        if self.mode == "normal":
+            if transition.state in {"failed", "interrupted"}:
+                self.output(
+                    f"activity> {transition.role.capitalize()} "
+                    f"{transition.state}: {transition.reason}"
+                )
+            return
+        self.output(
+            f"subagent> role={transition.role} run={run} "
+            f"state={transition.state} reason={transition.reason}"
+        )
+
+    def on_snapshot(
+        self,
+        task: SubAgentTask,
+        run_id: str,
+        snapshot: SubAgentSnapshotMetadata,
+        occurred_at: datetime,
+    ) -> None:
+        if self.mode != "debug":
+            return
+        self.output(
+            f"subagent_context> role={task.role} run={run_id[:8]} "
+            f"snapshot={snapshot.combined_sha256[:12]} "
+            f"instructions={len(snapshot.instructions.sources)} "
+            f"memory_entries={len(snapshot.memory.selected_entries)}"
+        )
+
+    def on_tool_audit(
+        self,
+        task: SubAgentTask,
+        run_id: str,
+        audit: SubAgentToolAudit,
+        occurred_at: datetime,
+    ) -> None:
+        if self.mode == "normal":
+            return
+        status = "ok" if audit.ok else "error"
+        details = [
+            f"subagent_tool> role={task.role}",
+            f"name={audit.tool_name}",
+            f"status={status}",
+        ]
+        if self.mode == "debug":
+            details.insert(1, f"run={run_id[:8]}")
+            details.append(f"args={audit.arguments_sha256[:12]}")
+            details.append(f"output_chars={audit.output_chars}")
+        if audit.exit_code is not None:
+            details.append(f"exit_code={audit.exit_code}")
+        if audit.duration_ms is not None:
+            details.append(f"duration_ms={audit.duration_ms}")
+        if audit.truncated:
+            details.append("truncated=true")
+        if audit.reason is not None:
+            details.append(f"reason={audit.reason}")
+        self.output(" ".join(details))
+
+    def on_result(
+        self,
+        task: SubAgentTask,
+        execution: SubAgentExecution,
+        occurred_at: datetime,
+    ) -> None:
+        if self.mode == "normal":
+            self.output(
+                f"activity> {execution.result.role.capitalize()} "
+                f"{execution.result.status}: {_summary(execution.result.summary)}"
+            )
+            return
+        usage = execution.token_usage
+        token_text = ""
+        if usage is not None:
+            token_text = f" tokens={usage.total_tokens}"
+        run_text = (
+            f" run={execution.result.run_id[:8]}" if self.mode == "debug" else ""
+        )
+        self.output(
+            f"subagent_result> role={execution.result.role}{run_text} "
+            f"status={execution.result.status} stop={execution.result.stop_reason}"
+            f"{token_text} summary={_summary(execution.result.summary)!r}"
+        )
+
+
+def _summary(value: str) -> str:
+    normalized = " ".join(value.split())
+    if len(normalized) <= CLI_SUBAGENT_SUMMARY_CHARS:
+        return normalized
+    return normalized[: CLI_SUBAGENT_SUMMARY_CHARS - 3].rstrip() + "..."