mindcode 0.2.0__py3-none-any.whl

mindcode/remote.py

@@ -0,0 +1,216 @@
+from __future__ import annotations
+
+import json
+import os
+import re
+import shlex
+import subprocess
+import time
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Any
+
+from .config import CONFIG_DIR
+
+
+REMOTES_FILE = CONFIG_DIR / "remotes.json"
+_ENV_NAME_RE = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
+
+
+@dataclass
+class RemoteConfig:
+    name: str
+    host: str
+    workdir: str
+    port: int = 22
+    identity_file: str | None = None
+    env: dict[str, str] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, name: str, data: dict[str, Any]) -> "RemoteConfig":
+        env = data.get("env", {})
+        if not isinstance(env, dict):
+            env = {}
+        return cls(
+            name=name,
+            host=str(data.get("host", "")),
+            port=int(data.get("port", 22) or 22),
+            workdir=str(data.get("workdir", "")),
+            identity_file=(
+                str(data["identity_file"]) if data.get("identity_file") else None
+            ),
+            env={str(key): str(value) for key, value in env.items()},
+        )
+
+    def validate(self) -> None:
+        if not self.name:
+            raise ValueError("remote name is required")
+        if not self.host:
+            raise ValueError("remote host is required")
+        if self.host.startswith("-") or any(
+            character.isspace() for character in self.host
+        ):
+            raise ValueError("remote host must not contain options or whitespace")
+        if not self.workdir:
+            raise ValueError("remote workdir is required")
+        if self.port <= 0:
+            raise ValueError("remote port must be positive")
+        for key in self.env:
+            if not _ENV_NAME_RE.match(key):
+                raise ValueError(f"invalid environment variable name: {key}")
+
+
+class RemoteStore:
+    def __init__(self, path: Path | None = None):
+        self.path = path or REMOTES_FILE
+
+    def load_all(self) -> dict[str, RemoteConfig]:
+        if not self.path.exists():
+            return {}
+        data = json.loads(self.path.read_text(encoding="utf-8"))
+        if not isinstance(data, dict):
+            return {}
+        remotes: dict[str, RemoteConfig] = {}
+        for name, raw in data.items():
+            if isinstance(raw, dict):
+                remotes[str(name)] = RemoteConfig.from_dict(str(name), raw)
+        return remotes
+
+    def save_all(self, remotes: dict[str, RemoteConfig]) -> None:
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        data = {
+            name: _config_payload(config)
+            for name, config in sorted(remotes.items())
+        }
+        tmp = self.path.with_suffix(".tmp")
+        tmp.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
+        os.chmod(tmp, 0o600)
+        tmp.replace(self.path)
+
+    def get(self, name: str) -> RemoteConfig:
+        remotes = self.load_all()
+        try:
+            return remotes[name]
+        except KeyError as exc:
+            raise KeyError(f"unknown remote: {name}") from exc
+
+    def add(self, config: RemoteConfig) -> None:
+        config.validate()
+        remotes = self.load_all()
+        remotes[config.name] = config
+        self.save_all(remotes)
+
+    def remove(self, name: str) -> bool:
+        remotes = self.load_all()
+        if name not in remotes:
+            return False
+        del remotes[name]
+        self.save_all(remotes)
+        return True
+
+
+@dataclass
+class RemoteResult:
+    argv: list[str]
+    exit_code: int
+    stdout: str
+    stderr: str
+    duration_s: float
+
+
+class SSHCommandBuilder:
+    def build_ssh_argv(self, config: RemoteConfig, remote_command: str) -> list[str]:
+        config.validate()
+        argv = [
+            "ssh",
+            "-p",
+            str(config.port),
+            "-o",
+            "StrictHostKeyChecking=accept-new",
+        ]
+        if config.identity_file:
+            argv.extend(["-i", str(Path(config.identity_file).expanduser())])
+        argv.append(config.host)
+        argv.append(self.build_remote_shell_command(config, remote_command))
+        return argv
+
+    def build_remote_shell_command(
+        self,
+        config: RemoteConfig,
+        remote_command: str,
+    ) -> str:
+        config.validate()
+        parts = [f"cd {shlex.quote(config.workdir)}"]
+        if config.env:
+            env_parts = [
+                f"{key}={shlex.quote(value)}" for key, value in sorted(config.env.items())
+            ]
+            parts.append("env " + " ".join(env_parts) + f" {remote_command}")
+        else:
+            parts.append(remote_command)
+        return " && ".join(parts)
+
+    def build_tail_command(
+        self,
+        path: str,
+        *,
+        lines: int = 80,
+        follow: bool = False,
+    ) -> str:
+        if lines <= 0:
+            raise ValueError("lines must be positive")
+        flags = ["tail", "-n", str(lines)]
+        if follow:
+            flags.append("-f")
+        flags.extend(["--", shlex.quote(path)])
+        return " ".join(flags)
+
+
+class RemoteExecutor:
+    def __init__(self, builder: SSHCommandBuilder | None = None):
+        self.builder = builder or SSHCommandBuilder()
+
+    def execute(
+        self,
+        config: RemoteConfig,
+        command: str,
+        *,
+        timeout_s: float | None = None,
+    ) -> RemoteResult:
+        argv = self.builder.build_ssh_argv(config, command)
+        started = time.monotonic()
+        try:
+            process = subprocess.run(
+                argv,
+                text=True,
+                capture_output=True,
+                timeout=timeout_s,
+                check=False,
+            )
+        except subprocess.TimeoutExpired as exc:
+            duration = time.monotonic() - started
+            return RemoteResult(
+                argv=argv,
+                exit_code=124,
+                stdout=exc.stdout or "",
+                stderr=exc.stderr or f"remote command timed out after {timeout_s}s",
+                duration_s=duration,
+            )
+        duration = time.monotonic() - started
+        return RemoteResult(
+            argv=argv,
+            exit_code=process.returncode,
+            stdout=process.stdout,
+            stderr=process.stderr,
+            duration_s=duration,
+        )
+
+
+def _config_payload(config: RemoteConfig) -> dict[str, Any]:
+    payload = asdict(config)
+    payload.pop("name", None)
+    return payload
+
+
+def mask_env(env: dict[str, str]) -> dict[str, str]:
+    return {key: "***" for key in env}

mindcode/render.py

@@ -0,0 +1,458 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from mindagent.core import AgentEvent, EventType
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.text import Text
+
+
+class RichRenderer:
+    """EventHandler implementation that renders agent events with rich.
+
+    Tracks a `_streaming` flag so TEXT_DELTA and tool-call events can flush
+    each other's line breaks correctly.
+    """
+
+    def __init__(self, console: Console | None = None) -> None:
+        self.console = console or Console()
+        self._streaming = False
+        self._did_stream = False
+        self.last_diff: str | None = None
+        self.last_edit_path: str | None = None
+        self._transcript: Any | None = None
+        self.total_tokens: int | None = None
+
+    def attach_transcript(self, transcript: Any) -> None:
+        """Send assistant Markdown into the shell TUI when one is active."""
+        self._transcript = transcript
+
+    def detach_transcript(self) -> None:
+        self._transcript = None
+
+    def reset(self) -> None:
+        self._flush_stream()
+        self._streaming = False
+        self._did_stream = False
+
+    async def __call__(self, event: AgentEvent) -> None:
+        handler = self._dispatch.get(event.event_type)
+        if handler is not None:
+            await handler(self, event)
+
+    async def _on_text_delta(self, event: AgentEvent) -> None:
+        if self._transcript is not None:
+            self._streaming = True
+            self._did_stream = True
+            self._transcript.append_delta(event.payload.get("delta", ""))
+            return
+        if not self._streaming:
+            self.console.print()
+            self.console.print("[bold cyan]assistant›[/bold cyan]", end=" ")
+            self._streaming = True
+            self._did_stream = True
+        delta = event.payload.get("delta", "")
+        self.console.out(delta, end="", highlight=False)
+
+    async def _on_action_started(self, event: AgentEvent) -> None:
+        self._flush_stream()
+        name = event.payload.get("action_name", "?")
+        args = event.payload.get("arguments", {}) or {}
+        if self._transcript is not None:
+            label, detail = _tui_tool_summary(name, args)
+            self._transcript.add_tool(label, detail)
+            return
+        risk = event.payload.get("risk", "")
+        risk_tag = f" [dim yellow][{risk}][/dim yellow]" if risk else ""
+
+        if name == "file_edit":
+            path = args.get("path", "?")
+            self.console.print(
+                f"  [bold blue]›[/bold blue] file_edit"
+                f" [cyan]{path}[/cyan]{risk_tag}"
+            )
+        elif name == "file_write":
+            path = args.get("path", "?")
+            self.console.print(
+                f"  [bold blue]›[/bold blue] file_write"
+                f" [cyan]{path}[/cyan]{risk_tag}"
+            )
+        elif name == "exec_command":
+            argv = args.get("argv") or args.get("command") or []
+            if isinstance(argv, str):
+                # 模型把 command 传成了字符串（应为数组）：整体展示，标注类型异常，
+                # 不要逐字符迭代（否则渲染成 "[ ' f i n d ' ..."）。
+                preview = argv
+                type_note = " [dim red](参数应为数组)[/dim red]"
+            else:
+                preview = " ".join(_quote(a) for a in argv)
+                type_note = ""
+            if len(preview) > 120:
+                preview = preview[:117] + "..."
+            self.console.print(
+                f"  [bold blue]›[/bold blue] exec [green]{preview}[/green]"
+                f"{type_note}{risk_tag}"
+            )
+        elif name == "file_read":
+            path = args.get("path", "?")
+            self.console.print(
+                f"  [bold blue]›[/bold blue] file_read [cyan]{path}[/cyan]"
+            )
+        else:
+            short = json.dumps(args, ensure_ascii=False)
+            if len(short) > 100:
+                short = short[:97] + "..."
+            self.console.print(
+                f"  [bold blue]›[/bold blue] [dim]{name}[/dim] {short}{risk_tag}"
+            )
+
+    async def _on_observation(self, event: AgentEvent) -> None:
+        name = event.payload.get("action_name", "?")
+        ok = event.payload.get("ok", False)
+        result = event.payload.get("result")
+        error = event.payload.get("error")
+
+        if self._transcript is not None:
+            self._render_tui_observation(name, ok, result, error)
+            return
+
+        if name in {"file_edit", "file_write"} and ok:
+            diff = result.get("mindcode_diff", "") if isinstance(result, dict) else ""
+            path = result.get("path", "") if isinstance(result, dict) else ""
+            if diff:
+                self.last_diff = diff
+                self.last_edit_path = path
+                self._render_diff_panel(diff, path)
+            else:
+                self.console.print(
+                    f"  [green]✓[/green] {name} [cyan]{path}[/cyan]"
+                    " [dim](无变化)[/dim]"
+                )
+            return
+
+        if name == "exec_command":
+            exit_code, timed_out, succeeded, reason = _command_status(
+                ok, result, error
+            )
+            if succeeded:
+                stdout = (
+                    result.get("stdout", "") if isinstance(result, dict) else ""
+                )
+                preview = _first_line(stdout)
+                if preview:
+                    self.console.print(
+                        f"  [green]✓[/green] exit=0 "
+                        f"[dim]{preview}[/dim]"
+                    )
+                else:
+                    self.console.print("  [green]✓[/green] exit=0")
+            else:
+                detail = _format_command_failure(
+                    exit_code,
+                    timed_out,
+                    reason,
+                    exit_separator="=",
+                )
+                self.console.print(f"  [red]✗[/red] {detail}")
+                stderr = (
+                    result.get("stderr", "") if isinstance(result, dict) else ""
+                )
+                if stderr:
+                    self._render_text_panel(stderr, "stderr", border="red")
+            return
+
+        status = "[green]✓[/green]" if ok else "[red]✗[/red]"
+        if ok:
+            self.console.print(f"  {status} [dim]{name}[/dim]")
+        else:
+            msg = error or "failed"
+            self.console.print(f"  {status} [dim]{name}:[/dim] {msg}")
+
+    async def _on_decision(self, event: AgentEvent) -> None:
+        kind = event.payload.get("decision_kind", "")
+        summary = event.payload.get("reasoning_summary") or ""
+        self._record_usage(event.payload.get("usage"))
+        if not summary:
+            return
+        preview = summary if len(summary) <= 80 else summary[:77] + "..."
+        if self._transcript is not None:
+            self._transcript.add_thinking(preview)
+            return
+        self.console.print(
+            f"  [dim italic][{kind}][/dim italic] [dim]{preview}[/dim]"
+        )
+
+    async def _on_error(self, event: AgentEvent) -> None:
+        self._flush_stream()
+        error = event.payload.get("error", "unknown error")
+        info = event.payload.get("error_info") or {}
+        body = error
+        if isinstance(info, dict):
+            code = info.get("code")
+            if code:
+                body = f"[{code}] {error}"
+        self.console.print(
+            Panel(
+                Text(body, style="red"),
+                border_style="red",
+                title="error",
+                title_align="left",
+            )
+        )
+
+    async def _on_completion_rejected(self, event: AgentEvent) -> None:
+        reasons = event.payload.get("reasons") or []
+        text = "\n".join(f"• {r}" for r in reasons)
+        self.console.print(
+            Panel(
+                Text(text or "完成声明被拒绝", style="yellow"),
+                border_style="yellow",
+                title="completion rejected",
+                title_align="left",
+            )
+        )
+
+    def _flush_stream(self) -> None:
+        if self._transcript is not None:
+            if self._streaming:
+                self._transcript.finish_stream()
+                self._streaming = False
+            return
+        if self._streaming:
+            self.console.print()
+            self._streaming = False
+
+    def render_final_answer(self, content: str) -> None:
+        """Render a non-streamed final answer in either shell presentation."""
+        if self._transcript is not None:
+            self._transcript.add_assistant(content)
+            return
+        self.console.print(f"\n[bold cyan]answer›[/bold cyan] {content}")
+
+    def _render_tui_observation(
+        self,
+        name: str,
+        ok: bool,
+        result: Any,
+        error: Any,
+    ) -> None:
+        """Update concise tool rows instead of exposing internal tool names."""
+        assert self._transcript is not None
+        if name in {"file_edit", "file_write"}:
+            diff = result.get("mindcode_diff", "") if isinstance(result, dict) else ""
+            path = result.get("path", "") if isinstance(result, dict) else ""
+            if ok and diff:
+                self.last_diff = diff
+                self.last_edit_path = path
+                self._transcript.finish_tool(True, f"updated {path}")
+                self._transcript.add_tool_detail(f"```diff\n{diff}\n```")
+            elif ok:
+                self._transcript.finish_tool(True, f"no changes {path}")
+            else:
+                self._transcript.finish_tool(False, str(error or "edit failed"))
+            return
+
+        if name == "exec_command":
+            exit_code, timed_out, succeeded, reason = _command_status(
+                ok, result, error
+            )
+            if succeeded:
+                stdout = result.get("stdout", "") if isinstance(result, dict) else ""
+                preview = _first_line(stdout)
+                detail = "exit 0"
+                if preview:
+                    detail += f" · {preview}"
+                self._transcript.finish_tool(True, detail)
+            else:
+                self._transcript.finish_tool(
+                    False,
+                    _format_command_failure(
+                        exit_code,
+                        timed_out,
+                        reason,
+                        exit_separator=" ",
+                    ),
+                )
+                stderr = result.get("stderr", "") if isinstance(result, dict) else ""
+                if stderr:
+                    self._transcript.add_tool_detail(f"```text\n{stderr}\n```")
+            return
+
+        self._transcript.finish_tool(
+            bool(ok),
+            "complete" if ok else str(error or "failed"),
+        )
+
+    def _record_usage(self, usage: Any) -> None:
+        if not isinstance(usage, dict):
+            return
+        total = usage.get("total_tokens")
+        if not isinstance(total, int) or total < 0:
+            return
+        self.total_tokens = (self.total_tokens or 0) + total
+
+    def _render_diff_panel(self, diff_text: str, path: str) -> None:
+        syntax = Syntax(
+            diff_text,
+            "diff",
+            theme="ansi_dark",
+            line_numbers=False,
+            word_wrap=True,
+            background_color="default",
+        )
+        self.console.print(
+            Panel(
+                syntax,
+                border_style="cyan",
+                title=f"diff: {path}",
+                title_align="left",
+            )
+        )
+
+    def _render_text_panel(
+        self,
+        text: str,
+        title: str,
+        *,
+        border: str = "dim",
+    ) -> None:
+        body = text if len(text) <= 2000 else text[:1997] + "..."
+        self.console.print(
+            Panel(
+                Text(body),
+                border_style=border,
+                title=title,
+                title_align="left",
+            )
+        )
+
+    _dispatch = {
+        EventType.TEXT_DELTA: _on_text_delta,
+        EventType.ACTION_STARTED: _on_action_started,
+        EventType.OBSERVATION_CREATED: _on_observation,
+        EventType.DECISION_CREATED: _on_decision,
+        EventType.ERROR_CREATED: _on_error,
+        EventType.COMPLETION_REJECTED: _on_completion_rejected,
+    }
+
+
+def _quote(arg: Any) -> str:
+    s = str(arg)
+    if any(c in s for c in {" ", "\t", "'", '"', "$"}):
+        return "'" + s.replace("'", "'\\''") + "'"
+    return s
+
+
+def _first_line(text: str, *, limit: int = 100) -> str:
+    if not text:
+        return ""
+    line = text.splitlines()[0] if text.splitlines() else ""
+    return line if len(line) <= limit else line[: limit - 3] + "..."
+
+
+def _command_status(
+    ok: bool,
+    result: Any,
+    error: Any,
+) -> tuple[int | None, bool, bool, str]:
+    """Return a user-facing status without inventing an exit code.
+
+    A missing or malformed ``exit_code`` means the command did not produce a
+    process result.  It must not be rendered as ``exit None``; use the
+    observation error (when available) as the primary failure reason instead.
+    """
+
+    payload = result if isinstance(result, dict) else {}
+    raw_exit_code = payload.get("exit_code")
+    exit_code = (
+        raw_exit_code
+        if isinstance(raw_exit_code, int) and not isinstance(raw_exit_code, bool)
+        else None
+    )
+    timed_out = bool(payload.get("timed_out", False))
+
+    if ok and exit_code == 0 and not timed_out:
+        return exit_code, timed_out, True, ""
+
+    reason = _error_text(error)
+    if exit_code is not None and exit_code != 0:
+        return exit_code, timed_out, False, reason
+
+    if timed_out:
+        return exit_code, timed_out, False, reason or "timed out"
+
+    if not ok:
+        return (
+            exit_code,
+            timed_out,
+            False,
+            reason or "command failed",
+        )
+
+    return exit_code, timed_out, False, reason or "missing exit code"
+
+
+def _format_command_failure(
+    exit_code: int | None,
+    timed_out: bool,
+    reason: str,
+    *,
+    exit_separator: str,
+) -> str:
+    """Format a failed command for one of the renderer presentations."""
+
+    if exit_code is not None and exit_code != 0:
+        detail = f"exit{exit_separator}{exit_code}"
+        if timed_out:
+            detail += " timeout" if exit_separator == "=" else " · timed out"
+        if reason:
+            detail += f" · {reason}"
+        return detail
+    if timed_out:
+        detail = "failed · timed out"
+        if reason and reason != "timed out":
+            detail += f" · {reason}"
+        return detail
+    return f"failed · {reason}"
+
+
+def _error_text(error: Any) -> str:
+    if isinstance(error, str):
+        return error.strip()
+    if error is None:
+        return ""
+    return str(error).strip()
+
+
+def _tui_tool_summary(name: str, args: Any) -> tuple[str, str]:
+    """Map runtime action names to compact, user-facing TUI labels."""
+    arguments = args if isinstance(args, dict) else {}
+    labels = {
+        "file_edit": "Edit",
+        "file_write": "Write",
+        "exec_command": "Command",
+        "file_read": "Read",
+        "memory_read": "Memory",
+        "delegate": "Delegate",
+    }
+    label = labels.get(name, name.replace("_", " ").title() or "Tool")
+
+    if name in {"file_edit", "file_write"}:
+        return label, str(arguments.get("path", ""))
+    if name == "exec_command":
+        command = arguments.get("argv") or arguments.get("command") or []
+        preview = command if isinstance(command, str) else " ".join(_quote(arg) for arg in command)
+        return label, _shorten(preview, 120)
+    if name == "file_read":
+        return label, str(arguments.get("path", ""))
+
+    detail = json.dumps(arguments, ensure_ascii=False)
+    return label, _shorten(detail, 100)
+
+
+def _shorten(text: str, limit: int) -> str:
+    return text if len(text) <= limit else text[: limit - 3] + "..."