mindcode 0.2.0__py3-none-any.whl

mindcode/bench/scorers/terminal_bench.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from mindagent.core import AgentResult
+
+from ..schema import BenchmarkCase, CaseTrace, ScoreResult
+
+
+class TerminalBenchRunScorer:
+    def score(
+        self,
+        case: BenchmarkCase,
+        run_result: AgentResult | None,
+        workspace: Path,
+        trace: CaseTrace,
+    ) -> ScoreResult:
+        passed = run_result is not None and run_result.error is None
+        return ScoreResult(
+            passed=passed,
+            score=1.0 if passed else 0.0,
+            metrics={"workspace_diff_bytes": len(trace.workspace_diff.encode("utf-8"))},
+            failure_phase=None if passed else "tool_execution",
+            failure_reason=None if passed else "agent_run_failed",
+        )

mindcode/bench/trace.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import Any
+
+from mindagent.core import AgentEvent, EventType
+
+from .jsonutil import to_jsonable
+
+
+class BenchmarkTraceRecorder:
+    def __init__(self) -> None:
+        self.agent_events: list[dict[str, Any]] = []
+        self.tool_calls: list[dict[str, Any]] = []
+
+    async def __call__(self, event: AgentEvent) -> None:
+        serialized = {
+            "event_id": event.event_id,
+            "run_id": event.run_id,
+            "event_type": event.event_type.value,
+            "state": event.state.value,
+            "timestamp": event.timestamp,
+            "payload": to_jsonable(event.payload),
+        }
+        self.agent_events.append(serialized)
+        if event.event_type == EventType.ACTION_STARTED:
+            payload = serialized["payload"]
+            self.tool_calls.append(
+                {
+                    "name": payload.get("action_name") or payload.get("name"),
+                    "arguments": payload.get("arguments", {}),
+                    "event_id": event.event_id,
+                    "timestamp": event.timestamp,
+                }
+            )

mindcode/bench/workspace.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+import difflib
+from pathlib import Path
+
+from mindagent.core.artifact import (
+    ensure_artifact_directory,
+    validate_artifact_path,
+)
+
+from .schema import BenchmarkCase
+
+
+def prepare_case_workspace(root: Path, case: BenchmarkCase) -> Path:
+    root = root.expanduser()
+    ensure_artifact_directory(root)
+    root = root.resolve()
+    workspace = (root / case.case_id).resolve()
+    try:
+        workspace.relative_to(root)
+    except ValueError as exc:
+        raise ValueError("benchmark case_id 不能超出 workspace root") from exc
+    workspace.mkdir(parents=True, exist_ok=True)
+    for item in case.files:
+        candidate = workspace / item.path
+        try:
+            validate_artifact_path(workspace, candidate)
+        except ValueError as exc:
+            raise ValueError(
+                f"benchmark file 不能超出 case workspace: {item.path}"
+            ) from exc
+        target = candidate.resolve()
+        try:
+            target.relative_to(workspace)
+        except ValueError as exc:
+            raise ValueError(
+                f"benchmark file 不能超出 case workspace: {item.path}"
+            ) from exc
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_text(item.content, encoding="utf-8")
+    return workspace
+
+
+def workspace_diff(case: BenchmarkCase, workspace: Path) -> str:
+    workspace = Path(workspace)
+    try:
+        # A symlinked workspace is outside the benchmark observation boundary
+        # even when its resolved target happens to exist.
+        if workspace.is_symlink():
+            return ""
+        resolved_workspace = workspace.resolve(strict=False)
+        if not resolved_workspace.is_dir():
+            return ""
+    except (OSError, RuntimeError):
+        return ""
+
+    parts: list[str] = []
+    initial = {item.path: item.content for item in case.files}
+    seen = set(initial)
+
+    for rel_path, before in sorted(initial.items()):
+        path = workspace / rel_path
+        after = _read_workspace_file(path, resolved_workspace)
+        if before != after:
+            parts.extend(
+                difflib.unified_diff(
+                    before.splitlines(keepends=True),
+                    after.splitlines(keepends=True),
+                    fromfile=f"a/{rel_path}",
+                    tofile=f"b/{rel_path}",
+                )
+            )
+
+    for path in sorted(workspace.rglob("*")):
+        if _workspace_entry(path, resolved_workspace) is None:
+            continue
+        if not path.is_file():
+            continue
+        rel_path = path.relative_to(workspace).as_posix()
+        if rel_path in seen:
+            continue
+        after = _read_workspace_file(path, resolved_workspace, errors="replace")
+        parts.extend(
+            difflib.unified_diff(
+                [],
+                after.splitlines(keepends=True),
+                fromfile=f"a/{rel_path}",
+                tofile=f"b/{rel_path}",
+            )
+        )
+
+    return "".join(parts)
+
+
+def _read_workspace_file(
+    path: Path,
+    workspace: Path,
+    *,
+    errors: str | None = None,
+) -> str:
+    """Read only ordinary files contained by the resolved workspace."""
+    if _workspace_entry(path, workspace) is None or not path.is_file():
+        return ""
+    try:
+        if errors is None:
+            return path.read_text(encoding="utf-8")
+        return path.read_text(encoding="utf-8", errors=errors)
+    except (OSError, UnicodeError):
+        return ""
+
+
+def _workspace_entry(path: Path, workspace: Path) -> Path | None:
+    """Return a path only when no component follows a symlink or escapes."""
+    try:
+        if path.is_symlink():
+            return None
+        resolved = path.resolve(strict=False)
+        resolved.relative_to(workspace)
+        relative = path.relative_to(workspace)
+        current = workspace
+        for component in relative.parts:
+            current /= component
+            if current.is_symlink():
+                return None
+        return path
+    except (OSError, RuntimeError, ValueError):
+        return None

mindcode/cli/__init__.py

@@ -0,0 +1,112 @@
+"""mindcode CLI 入口：typer app + 命令注册。
+
+模块结构（对齐 mindbot/src/mindbot/cli/）：
+    cli/__init__.py           typer app + 命令注册
+    cli/_shared.py            共享 console + find_config_file
+    cli/commands/
+        shell.py              `mindcode shell`（默认子命令）
+        chat.py               `mindcode chat -m "..."`
+        task.py               `mindcode task run/list/status/tail`
+        status.py             `mindcode status`
+        config_cmd.py         `mindcode config providers/models/api-key/...`
+    cli/shell/
+        __init__.py           暴露 Shell / run_shell
+        repl.py               Shell 类 + REPL 主循环
+        slash.py              slash 命令分发
+        menu.py               interactive_menu（ChoiceInput 包装）
+        startup.py            build_welcome_banner
+"""
+
+from __future__ import annotations
+
+import typer
+
+from .._version import __version__
+from ._shared import console
+
+KNOWN_SUBCOMMANDS = {
+    "shell",
+    "chat",
+    "status",
+    "config",
+    "bench",
+    "task",
+    "remote",
+    "terminal",
+}
+
+
+class DefaultShellGroup(typer.core.TyperGroup):
+    """让 `mindcode`（不带子命令）默认进 shell。
+
+    当第一个非 flag 参数不是已知子命令时，把 "shell" 注入到 args 前面，
+    让 click 走完整的参数解析路径。
+    """
+
+    def parse_args(self, ctx, args):
+        if args:
+            first = args[0]
+            if (
+                first in KNOWN_SUBCOMMANDS
+                or first in {"--help", "-h", "--version", "-v"}
+            ):
+                return super().parse_args(ctx, args)
+        # 无子命令或第一参数是 shell 的 flag/位置参数 → 注入 shell
+        new_args = ["shell", *args]
+        return super().parse_args(ctx, new_args)
+
+
+app = typer.Typer(
+    name="mindcode",
+    help=(
+        f"mindcode v{__version__} — task execution and development "
+        "supervision agent"
+    ),
+    cls=DefaultShellGroup,
+    no_args_is_help=False,
+    add_completion=False,
+)
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        console.print(f"mindcode v{__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: bool = typer.Option(
+        None,
+        "--version",
+        "-v",
+        callback=_version_callback,
+        is_eager=True,
+        help="显示版本号",
+    ),
+) -> None:
+    """mindcode — task execution and development supervision agent."""
+
+
+# 子命令注册
+from .commands.chat import chat  # noqa: E402
+from .commands.bench import app as bench_app  # noqa: E402
+from .commands.config_cmd import app as config_app  # noqa: E402
+from .commands.remote import app as remote_app  # noqa: E402
+from .commands.shell import shell  # noqa: E402
+from .commands.status import status  # noqa: E402
+from .commands.task import app as task_app  # noqa: E402
+from .commands.terminal import app as terminal_app  # noqa: E402
+
+app.command("shell")(shell)
+app.command()(chat)
+app.command()(status)
+app.add_typer(config_app, name="config")
+app.add_typer(bench_app, name="bench")
+app.add_typer(task_app, name="task")
+app.add_typer(remote_app, name="remote")
+app.add_typer(terminal_app, name="terminal")
+
+
+if __name__ == "__main__":
+    app()

mindcode/cli/_shared.py

@@ -0,0 +1,43 @@
+"""CLI 共享工具：全局 console 实例与配置文件定位。"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+from rich.console import Console
+
+from ..config import CONFIG_FILE
+
+
+class _StdoutProxy:
+    """每次 write 时动态查 sys.stdout，使 patch_stdout 能拦截 Rich 输出。"""
+
+    def write(self, data: str) -> int:
+        return sys.stdout.write(data)
+
+    def flush(self) -> None:
+        sys.stdout.flush()
+
+    def isatty(self) -> bool:
+        return sys.stdout.isatty()
+
+
+console = Console(file=_StdoutProxy())
+
+
+def mask_key(key: str) -> str:
+    if not key:
+        return "[red](未设置)[/red]"
+    if len(key) <= 8:
+        return "*" * len(key)
+    return key[:4] + "..." + key[-4:]
+
+
+def find_config_file() -> Path:
+    """返回配置文件路径（首次访问时自动 bootstrap）。"""
+    if not CONFIG_FILE.exists():
+        from ..config import load_config
+
+        load_config()
+    return CONFIG_FILE

mindcode/cli/commands/__init__.py

@@ -0,0 +1 @@
+"""commands 子包入口。"""