mindcode 0.3.2__py3-none-any.whl → 0.5.2__py3-none-any.whl

mindcode/_version.py

@@ -1,6 +1,6 @@
 """mindcode 版本与品牌信息。"""
 
-__version__ = "0.3.1"
+__version__ = "0.5.2"
 
 __logo__ = r"""
 [bold cyan]                           _           _[/bold cyan]

mindcode/acp_agent/__init__.py

@@ -0,0 +1,5 @@
+"""mindcode ACP agent adapter (see docs/acp-layering.md)."""
+
+from .agent import PROTOCOL_VERSION, build_harness
+
+__all__ = ["PROTOCOL_VERSION", "build_harness"]

mindcode/acp_agent/__main__.py

@@ -0,0 +1,70 @@
+"""ACP agent entry point: ``python -m mindcode.acp_agent``.
+
+stdio transport only.  stdout carries ACP JSON-RPC frames exclusively; all
+logging is routed to stderr (see docs/acp-layering.md §5 rule 1).
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import logging
+import sys
+from pathlib import Path
+
+from acp import run_agent
+
+from .agent import _AgentHarness
+
+
+def _setup_logging(verbose: bool) -> None:
+    logging.basicConfig(
+        stream=sys.stderr,
+        level=logging.DEBUG if verbose else logging.INFO,
+        format="%(asctime)s %(name)s %(levelname)s %(message)s",
+    )
+    # 第三方库的 INFO 噪音也压到 stderr，绝不污染 stdout
+    logging.getLogger().setLevel(logging.DEBUG if verbose else logging.INFO)
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="python -m mindcode.acp_agent",
+        description="Run the mindcode ACP agent over stdio (ACP v1).",
+    )
+    parser.add_argument(
+        "--cwd",
+        default=None,
+        help="Default workspace used when a client connects without a cwd",
+    )
+    parser.add_argument("--verbose", action="store_true", help="stderr debug logs")
+    args = parser.parse_args(argv)
+
+    _setup_logging(args.verbose)
+
+    async def _serve() -> int:
+        harness_holder: list[_AgentHarness] = []
+
+        def factory(conn: object) -> _AgentHarness:
+            harness = _AgentHarness(
+                conn,  # type: ignore[arg-type]
+                cwd=Path(args.cwd).expanduser() if args.cwd else None,
+            )
+            harness_holder.append(harness)
+            return harness
+
+        try:
+            await run_agent(factory)
+        finally:
+            if harness_holder:
+                await harness_holder[0].close()
+        return 0
+
+    try:
+        return asyncio.run(_serve())
+    except KeyboardInterrupt:
+        return 130
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

mindcode/acp_agent/agent.py

@@ -0,0 +1,469 @@
+"""ACP agent adapter — exposes mindcode's native session API over ACP v1.
+
+Layering (see docs/acp-layering.md):
+
+    engine (mindagent-core) → native session API (this file's only bus)
+        → ACP stdio JSON-RPC (acp SDK, ``python -m mindcode.acp_agent``)
+        → TUI Shell (untouched, peer frontend)
+
+Only the five native ports are used: create session / run turn / cancel /
+approval callback / event stream.  Hard rules honoured here:
+
+- stdout carries protocol frames only; every log line goes to stderr.
+- one run per session at a time; a second ``session/prompt`` is rejected.
+- provider/model/approval configuration always comes from ``ConfigStore``
+  (fresh ``read()`` per session); clients cannot widen the SessionPolicy.
+- unimplemented stable methods (``session/load``, ``session/set_mode``)
+  answer with a JSON-RPC error instead of pretending support.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from acp import AgentSideConnection, helpers, RequestError
+from acp.schema import (
+    AgentCapabilities,
+    InitializeResponse,
+    NewSessionResponse,
+    PermissionOption,
+    PromptCapabilities,
+    PromptResponse,
+    RequestPermissionResponse,
+    TextContentBlock,
+    ToolCallStart,
+)
+
+from mindagent.core import (
+    AgentSession,
+    AgentRuntime,
+    EventType,
+    LocalConversationStore,
+    RunOutcome,
+    SessionEnvironment,
+    SessionEventType,
+    SessionPolicy,
+)
+from ..approval import describe_action
+from ..config import ConfigError, ConfigStore, ProviderConfig
+from ..policy import ApprovalMode
+from ..runtime import build_runtime
+
+logger = logging.getLogger("mindcode.acp_agent")
+
+PROTOCOL_VERSION = 1  # stable ACP v1; see docs/acp-layering.md §5
+
+_PERMISSION_TIMEOUT_S = 120.0
+
+
+def _stop_reason(result: Any) -> str:
+    """Map a native run result to an ACP v1 stop reason (layering §3)."""
+    outcome = getattr(result, "outcome", None)
+    if outcome is RunOutcome.CANCELLED:
+        return "cancelled"
+    if outcome in (RunOutcome.ERROR, RunOutcome.PARTIAL):
+        return "refusal"
+    return "end_turn"
+
+
+def _tool_kind(action_name: str) -> str:
+    if action_name.startswith("file_read"):
+        return "read"
+    if action_name in ("file_write", "file_edit"):
+        return "edit"
+    if action_name.startswith("exec_") or "command" in action_name:
+        return "execute"
+    if "search" in action_name or "glob" in action_name or "grep" in action_name:
+        return "search"
+    return "other"
+
+
+def _extract_text(prompt: list[Any]) -> str:
+    parts: list[str] = []
+    for block in prompt:
+        if isinstance(block, TextContentBlock):
+            parts.append(block.text)
+        else:
+            raise RequestError.invalid_params(
+                "only text content blocks are supported"
+            )
+    return "".join(parts)
+
+
+@dataclass
+class _ToolCallTracker:
+    """ACTION_STARTED → OBSERVATION_CREATED bookkeeping per session."""
+
+    by_action: dict[str, ToolCallStart] = field(default_factory=dict)
+
+
+class _ManagedSession:
+    """Native session plus the per-session serialisation state."""
+
+    def __init__(self, session_id: str, session: AgentSession, runtime: AgentRuntime):
+        self.session_id = session_id
+        self.session = session
+        self.runtime = runtime
+        self.turn_lock = asyncio.Lock()
+        self.tool_calls = _ToolCallTracker()
+
+
+class _AgentHarness:
+    """Owns ACP sessions; each maps to one native ``AgentSession``."""
+
+    def __init__(
+        self,
+        conn: AgentSideConnection,
+        *,
+        config_store: ConfigStore | None = None,
+        cwd: Path | None = None,
+        subagents: bool = False,
+        permission_timeout_s: float = _PERMISSION_TIMEOUT_S,
+    ) -> None:
+        self._conn = conn
+        self._config_store = config_store or ConfigStore()
+        self._cwd = cwd or Path.cwd()
+        self._subagents = subagents
+        self._permission_timeout_s = permission_timeout_s
+        self._sessions: dict[str, _ManagedSession] = {}
+        self._new_session_lock = asyncio.Lock()
+
+    # ----- ACP agent methods (stable surface only) -----
+
+    async def initialize(
+        self,
+        protocol_version: int,
+        client_capabilities: Any | None = None,
+        client_info: Any | None = None,
+        **kwargs: Any,
+    ) -> InitializeResponse:
+        logger.info(
+            "initialize: client=%s protocol=%s",
+            getattr(client_info, "name", "unknown"),
+            protocol_version,
+        )
+        return InitializeResponse(
+            protocol_version=PROTOCOL_VERSION,
+            agent_capabilities=AgentCapabilities(
+                load_session=False,
+                prompt_capabilities=PromptCapabilities(),
+            ),
+        )
+
+    async def new_session(
+        self,
+        cwd: str,
+        mcp_servers: list[Any] | None = None,
+        **kwargs: Any,
+    ) -> NewSessionResponse:
+        if mcp_servers:
+            raise RequestError.invalid_request(
+                "mcpServers are not supported by mindcode yet"
+            )
+        async with self._new_session_lock:
+            workspace = Path(cwd).expanduser() if cwd else self._cwd
+            try:
+                resolved = self._config_store.resolve()
+            except ConfigError as exc:
+                raise RequestError.internal_error(str(exc)) from exc
+            store = LocalConversationStore(
+                self._config_store.root / "sessions"
+            )
+            runtime = build_runtime(
+                workspace,
+                provider_config=resolved,
+                approve_mode=ApprovalMode(resolved.approval_mode),
+                stream=True,
+                event_handler=None,
+                approval_callback=self._make_approval(resolved),
+            )
+            try:
+                session = runtime.create_session(
+                    environment=SessionEnvironment(
+                        workspace_root=workspace,
+                        working_directory=workspace,
+                    ),
+                    policy=SessionPolicy(
+                        allow_write=True,
+                        allow_dangerous=False,
+                        max_parallel_actions=1,
+                    ),
+                    conversation_store=store,
+                )
+            except Exception:
+                await runtime.close(close_dependencies=True)
+                raise
+            session_id = session.session_id
+            self._sessions[session_id] = _ManagedSession(
+                session_id, session, runtime
+            )
+            logger.info(
+                "session %s created (workspace=%s provider=%s model=%s approval=%s)",
+                session_id,
+                workspace,
+                resolved.name,
+                resolved.model,
+                resolved.approval_mode,
+            )
+            return NewSessionResponse(session_id=session_id)
+
+    async def prompt(
+        self,
+        session_id: str,
+        prompt: list[Any],
+        **kwargs: Any,
+    ) -> PromptResponse:
+        managed = self._managed(session_id)
+        text = _extract_text(prompt)
+        if not text.strip():
+            raise RequestError.invalid_params("prompt must contain text")
+        if managed.turn_lock.locked():
+            # 铁律 2：每 session 串行，第二轮直接拒收（参照 COMMAND_REJECTED 语义）。
+            raise RequestError.invalid_request(
+                f"session {session_id} already has an active run"
+            )
+        async with managed.turn_lock:
+            return await self._run_turn(managed, text)
+
+    async def cancel(self, session_id: str, **kwargs: Any) -> None:
+        managed = self._managed(session_id)
+        run_id = managed.session.active_run_id
+        if run_id:
+            logger.info("cancel session=%s run=%s", session_id, run_id)
+            await managed.session.cancel_run(run_id)
+
+    async def set_session_mode(
+        self, session_id: str, mode_id: str, **kwargs: Any
+    ) -> None:
+        raise RequestError.invalid_request(
+            "session/set_mode is not supported yet (planned P2)"
+        )
+
+    async def load_session(self, *args: Any, **kwargs: Any) -> None:
+        raise RequestError.invalid_request(
+            "session/load is not supported yet (planned P2)"
+        )
+
+    # ----- internals -----
+
+    def _managed(self, session_id: str) -> _ManagedSession:
+        managed = self._sessions.get(session_id)
+        if managed is None:
+            raise RequestError.resource_not_found(session_id)
+        return managed
+
+    async def close(self) -> None:
+        for managed in list(self._sessions.values()):
+            try:
+                await managed.runtime.close(close_dependencies=True)
+            except Exception:
+                logger.exception("failed closing session %s", managed.session_id)
+        self._sessions.clear()
+
+    # ----- approval bridge (native port 4 → session/request_permission) -----
+
+    def _make_approval(self, provider_config: ProviderConfig) -> Any:
+        async def approve(context: Any, action: Any) -> bool:
+            managed = self._managed(context.session_id)
+            summary = describe_action(action)
+            started = helpers.start_tool_call(
+                tool_call_id=f"perm-{int(time.time() * 1000)}",
+                title=summary,
+                kind=_tool_kind(getattr(action, "name", "")),
+                status="pending",
+            )
+            await self._notify_update(managed, started)
+            options = [
+                PermissionOption(
+                    option_id="allow", name="Allow", kind="allow_once"
+                ),
+                PermissionOption(
+                    option_id="reject", name="Reject", kind="reject_once"
+                ),
+            ]
+            try:
+                response = await asyncio.wait_for(
+                    self._conn.request_permission(
+                        session_id=managed.session_id,
+                        tool_call=started,
+                        options=options,
+                    ),
+                    timeout=self._permission_timeout_s,
+                )
+            except asyncio.TimeoutError:
+                logger.warning(
+                    "permission timed out after %.0fs → deny (unattended)",
+                    self._permission_timeout_s,
+                )
+                return False
+            outcome = response.outcome
+            option_id = getattr(outcome, "option_id", None)
+            if getattr(outcome, "outcome", None) == "cancelled":
+                return False
+            return option_id == "allow"
+
+        return approve
+
+    # ----- event-stream translation (native port 5 → session/update) -----
+
+    async def _notify_update(self, managed: _ManagedSession, update: Any) -> None:
+        await self._conn.session_update(
+            session_id=managed.session_id,
+            update=update,
+        )
+
+    async def _run_turn(self, managed: _ManagedSession, text: str) -> PromptResponse:
+        session = managed.session
+        checkpoint = session.pending_checkpoint
+        if checkpoint is None:
+            command_id = await session.submit_run(text)
+        else:
+            command_id = await session.continue_run(
+                checkpoint.checkpoint_id, user_input=text
+            )
+        while True:
+            event = await session.next_event()
+            if event.event_type == SessionEventType.RUN_ACCEPTED:
+                continue
+            if event.event_type == SessionEventType.AGENT_EVENT:
+                agent_event = event.agent_event
+                if agent_event is None:
+                    continue
+                await self._on_agent_event(managed, agent_event)
+                continue
+            if event.event_type in (
+                SessionEventType.APPROVAL_DECIDED,
+                SessionEventType.USER_MESSAGE_APPENDED,
+            ):
+                continue
+            if event.event_type == SessionEventType.RUN_INTERRUPTED:
+                return PromptResponse(stop_reason="cancelled")
+            if event.event_type == SessionEventType.RUN_COMPLETED:
+                if event.correlation_id and event.correlation_id != command_id:
+                    # 中断跟随：旧一轮收尾后新一轮接管，继续等新一轮。
+                    command_id = event.correlation_id
+                    continue
+                result = event.payload.get("result")
+                if result is None:
+                    logger.error(
+                        "run %s failed: %s",
+                        event.run_id,
+                        event.payload.get("error"),
+                    )
+                    return PromptResponse(stop_reason="refusal")
+                return PromptResponse(stop_reason=_stop_reason(result))
+            if event.event_type == SessionEventType.COMMAND_REJECTED:
+                logger.error(
+                    "command rejected: %s",
+                    event.payload.get("reason", "unknown"),
+                )
+                return PromptResponse(stop_reason="refusal")
+            if event.event_type == SessionEventType.USER_INPUT_REQUIRED:
+                logger.warning(
+                    "USER_INPUT_REQUIRED without approval bridge; cancelling run"
+                )
+                run_id = event.run_id or session.active_run_id
+                if run_id:
+                    await session.cancel_run(run_id)
+                continue
+
+    async def _on_agent_event(self, managed: _ManagedSession, agent_event: Any) -> None:
+        event_type = agent_event.event_type
+        payload = agent_event.payload or {}
+        if event_type == EventType.TEXT_DELTA:
+            delta = payload.get("delta", "")
+            if delta:
+                await self._notify_update(
+                    managed, helpers.update_agent_message_text(delta)
+                )
+        elif event_type == EventType.ACTION_STARTED:
+            action_name = payload.get("action_name", "tool")
+            arguments = payload.get("arguments", {}) or {}
+            title = _describe_started(action_name, arguments)
+            started = helpers.start_tool_call(
+                tool_call_id=_tool_call_key(agent_event),
+                title=title,
+                kind=_tool_kind(action_name),
+                status="in_progress",
+                raw_input=arguments,
+            )
+            managed.tool_calls.by_action[_tool_call_key(agent_event)] = started
+            await self._notify_update(managed, started)
+        elif event_type == EventType.OBSERVATION_CREATED:
+            key = _tool_call_key(agent_event)
+            started = managed.tool_calls.by_action.pop(key, None)
+            ok = bool(payload.get("ok", False))
+            output = _observation_text(payload)
+            if started is not None:
+                progress = helpers.update_tool_call(
+                    started.tool_call_id,
+                    status="completed" if ok else "failed",
+                    content=[helpers.tool_content(helpers.text_block(output))],
+                    raw_output=payload.get("result"),
+                )
+                await self._notify_update(managed, progress)
+        elif event_type == EventType.ERROR_CREATED:
+            message = str(payload.get("error", "unknown error"))
+            logger.error("agent error: %s", message)
+        elif event_type == EventType.DECISION_CREATED:
+            # reasoning summary: forward as thought chunk when present
+            summary = payload.get("reasoning_summary")
+            if summary:
+                await self._notify_update(
+                    managed, helpers.update_agent_thought_text(str(summary))
+                )
+        # 其他事件类型（COMPLETION_REJECTED 等）记日志即可
+        else:
+            logger.debug("untranslated agent event: %s", event_type)
+
+
+def _tool_call_key(agent_event: Any) -> str:
+    action_id = getattr(agent_event, "action_id", None) or getattr(
+        agent_event, "action_batch_id", None
+    )
+    if action_id:
+        return str(action_id)
+    payload = agent_event.payload or {}
+    return str(payload.get("action_id") or payload.get("batch_id") or "tool")
+
+
+def _describe_started(action_name: str, arguments: dict[str, Any]) -> str:
+    target = arguments.get("path") or arguments.get("command") or ""
+    title = f"{action_name} {target}".strip()
+    return title if title else action_name
+
+
+def _observation_text(payload: dict[str, Any]) -> str:
+    if payload.get("ok", False):
+        result = payload.get("result")
+        if isinstance(result, dict):
+            diff = result.get("mindcode_diff")
+            if diff:
+                return str(diff)
+            output = result.get("output") or result.get("content")
+            if output:
+                return str(output)
+        return "ok"
+    error = payload.get("error") or "failed"
+    return str(error)
+
+
+def build_harness(
+    conn: AgentSideConnection,
+    *,
+    config_store: ConfigStore | None = None,
+    cwd: Path | None = None,
+    subagents: bool = False,
+) -> _AgentHarness:
+    """Factory used by ``__main__`` and tests."""
+    return _AgentHarness(
+        conn,
+        config_store=config_store,
+        cwd=cwd,
+        subagents=subagents,
+    )

mindcode/approval.py

@@ -90,14 +90,14 @@ def make_shell_approval(
             result = await chooser(
                 f"允许执行？ {summary}",
                 [("allow", "允许"), ("deny", "拒绝")],
-                "deny",
+                "allow",
             )
             return result == "allow"
         # Lazy import：非交互进程构造 policy 时不引入 prompt_toolkit。
         from .cli.shell.menu import prompt_yes_no
 
         return await prompt_yes_no(
-            f"允许执行 {summary}?", default_yes=False
+            f"允许执行 {summary}?", default_yes=True
         )
 
     return _approve
@@ -119,12 +119,12 @@ def make_shell_file_access_approval(
         chooser = get_chooser()
         if chooser is not None:
             result = await chooser(
-                title, [("allow", "允许此次只读访问"), ("deny", "拒绝")], "deny",
+                title, [("allow", "允许此次只读访问"), ("deny", "拒绝")], "allow",
             )
             approved = result == "allow"
         else:
             from .cli.shell.menu import prompt_yes_no
-            approved = await prompt_yes_no(title, default_yes=False)
+            approved = await prompt_yes_no(title, default_yes=True)
         return ExternalFileReadDecision(request_id=request.request_id, approved=approved)
 
     return approve

mindcode/bench/runner.py

@@ -12,7 +12,7 @@ from mindagent.core.artifact import (
     write_artifact_text,
 )
 
-from ..config import load_config
+from ..config import ConfigStore
 from ..policy import ApprovalMode
 from ..runtime import build_runtime
 from .adapters import built_in_adapters
@@ -115,13 +115,15 @@ class MindcodeBenchmarkRunner:
         runtime = None
 
         try:
-            mindcode_config = load_config()
-            provider_config = mindcode_config.get_provider(config.provider)
+            provider_config = ConfigStore().resolve(
+                provider_override=config.provider,
+                model_override=config.model,
+                approval_override=config.approve_mode,
+            )
             runtime = build_runtime(
                 workspace,
                 provider_config=provider_config,
                 approve_mode=ApprovalMode(config.approve_mode),
-                model=config.model,
                 stream=False,
                 event_handler=recorder,
                 max_steps=config.max_steps,

mindcode/cli/_shared.py

@@ -7,7 +7,7 @@ from pathlib import Path
 
 from rich.console import Console
 
-from ..config import CONFIG_FILE
+from ..config import CONFIG_DIR, ConfigStore
 
 
 class _StdoutProxy:
@@ -36,8 +36,6 @@ def mask_key(key: str) -> str:
 
 def find_config_file() -> Path:
     """返回配置文件路径（首次访问时自动 bootstrap）。"""
-    if not CONFIG_FILE.exists():
-        from ..config import load_config
-
-        load_config()
-    return CONFIG_FILE
+    store = ConfigStore(CONFIG_DIR)
+    store.bootstrap()
+    return store.config_path

mindcode/cli/commands/bench.py

@@ -31,7 +31,7 @@ from ...bench.runner import (
     run_benchmark,
 )
 from ...bench.schema import BenchmarkRunConfig
-from ...config import load_config
+from ...config import ConfigStore
 from ...policy import ApprovalMode
 from .._shared import console
 
@@ -70,8 +70,8 @@ def run(
         help="覆盖 default_provider",
     ),
     model: str | None = typer.Option(None, "--model", help="覆盖模型"),
-    approve_mode: str = typer.Option(
-        ApprovalMode.FULL_ACCEPT.value,
+    approve_mode: str | None = typer.Option(
+        None,
         "--approve-mode",
         case_sensitive=False,
         help="权限模式：ask_user 逐项询问，full_accept 全部接受",
@@ -93,18 +93,27 @@ def run(
         help="每 case 总超时秒数",
     ),
 ) -> None:
-    config = load_config()
-    provider_name = provider or config.default_provider
     run_id = f"{suite}-{time.strftime('%Y%m%d-%H%M%S')}"
     try:
+        approval_override = (
+            ApprovalMode(approve_mode).value
+            if approve_mode is not None
+            else None
+        )
+        resolved = ConfigStore().resolve(
+            provider_override=provider,
+            model_override=model,
+            approval_override=approval_override,
+        )
+        selected_approve_mode = resolved.approval_mode
         output_root = Path(output).expanduser()
         run_output_dir = _run_output_dir(output_root, run_id)
         run_config = BenchmarkRunConfig(
             suite=suite,
             run_id=run_id,
-            provider=provider_name,
-            model=model,
-            approve_mode=ApprovalMode(approve_mode).value,
+            provider=resolved.name,
+            model=resolved.model,
+            approve_mode=selected_approve_mode,
             workspace_root=run_output_dir / "workspaces",
             output_root=output_root,
             limit=limit,