mindcode 0.2.0__py3-none-any.whl

mindcode/__init__.py

@@ -0,0 +1,5 @@
+"""mindcode — task execution and development supervision agent."""
+
+from ._version import __logo__, __version__
+
+__all__ = ["__logo__", "__version__"]

mindcode/__main__.py

@@ -0,0 +1,4 @@
+from .cli import app
+
+if __name__ == "__main__":
+    app()

mindcode/_version.py

@@ -0,0 +1,11 @@
+"""mindcode 版本与品牌信息。"""
+
+__version__ = "0.2.0"
+
+__logo__ = r"""
+[bold cyan]                           _           _[/bold cyan]
+[bold cyan]  _ __ ___   ___ _ __ ___ (_) ___  ___| |_[/bold cyan]
+[bold cyan] | '_ ` _ \ / _ \ '_ ` _ \| |/ _ \/ __| __|[/bold cyan]
+[bold cyan] | | | | | |  __/ | | | | | |  __/ (__| |_[/bold cyan]
+[bold cyan] |_| |_| |_|\___|_| |_| |_|_|\___|\___|\__|[/bold cyan]
+"""

mindcode/approval.py

@@ -0,0 +1,105 @@
+"""审批文案与审批回调装配（TUI 优先，裸终端回退）。
+
+``describe_action`` 只依赖 ``mindagent.core`` 的数据结构，不碰
+prompt_toolkit；``make_shell_approval`` 在运行时动态读取 chooser，
+TUI 全屏运行时走 ``MindcodeTui.choose`` 的 RadioList 浮层，
+one-shot / TUI 未启动时回退到 ``menu.prompt_yes_no``。
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Awaitable, Callable
+from typing import Any
+
+from mindagent.core import ActionRequest, AgentContext
+
+from .policy import ApprovalCallback
+
+
+def risk_label(risk: Any) -> str:
+    """ActionRisk 中文化；未知值回退到其 value/str。"""
+    from mindagent.core import ActionRisk
+
+    mapping = {
+        ActionRisk.READ_ONLY: "只读",
+        ActionRisk.WRITE: "写操作",
+        ActionRisk.DANGEROUS: "危险操作",
+    }
+    if risk in mapping:
+        return mapping[risk]
+    return str(getattr(risk, "value", risk))
+
+
+def _one_line(text: Any) -> str:
+    return str(text).replace("\r", " ").replace("\n", " ")
+
+
+def describe_action(action: ActionRequest) -> str:
+    """按工具类型生成一行友好摘要（保证单行，供 TUI 单行 title 用）。"""
+    name = action.name
+    arguments = (
+        action.arguments if isinstance(action.arguments, dict) else {}
+    )
+    if name in ("file_edit", "file_write"):
+        verb = "Edit" if name == "file_edit" else "Write"
+        path = _one_line(arguments.get("path", "?"))
+        return f"{verb} {path} [{risk_label(action.risk)}]"
+    if name == "exec_command":
+        command = arguments.get("command", "")
+        if isinstance(command, list):
+            preview = " ".join(_one_line(item) for item in command)
+        else:
+            preview = _one_line(command)
+        if len(preview) > 120:
+            preview = preview[:117] + "..."
+        return f"Command {preview} [{risk_label(action.risk)}]"
+    if name in ("file_read", "memory_read"):
+        path = _one_line(arguments.get("path", "?"))
+        return f"Read {path} [{risk_label(action.risk)}]"
+    payload = json.dumps(arguments, ensure_ascii=False, sort_keys=True)
+    if len(payload) > 240:
+        payload = payload[:237] + "..."
+    return f"{name} {payload}"
+
+
+Chooser = Callable[
+    [str, list[tuple[str, str]], str | None],
+    Awaitable[str | None],
+]
+
+
+def make_shell_approval(
+    get_chooser: Callable[[], Chooser | None],
+) -> ApprovalCallback:
+    """装配 `(context, action) -> bool` 审批回调。
+
+    TUI 运行时 ``get_chooser()`` 返回 ``MindcodeTui.choose``（与 slash
+    命令的 ``_choose_option`` 同一条路），用 RadioList 浮层二选一；
+    返回 None（取消/Esc/TUI 未运行）一律视为拒绝。chooser 不可用时
+    回退到裸 ``menu.prompt_yes_no``（one-shot / 非 TUI 路径）。
+    """
+
+    async def _approve(
+        context: AgentContext,
+        action: ActionRequest,
+    ) -> bool:
+        summary = describe_action(action)
+        chooser = get_chooser()
+        if chooser is not None:
+            # choose 的 dialog title 是 height=1 的单行 Window，
+            # 多行会被裁掉，故 summary 必须压成单行。
+            result = await chooser(
+                f"允许执行？ {summary}",
+                [("allow", "允许"), ("deny", "拒绝")],
+                "deny",
+            )
+            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
+        )
+
+    return _approve

mindcode/bench/__init__.py

@@ -0,0 +1,19 @@
+"""Benchmark facility for mindcode."""
+
+from .schema import (
+    BenchmarkCase,
+    BenchmarkFile,
+    BenchmarkResult,
+    BenchmarkRunConfig,
+    CaseTrace,
+    ScoreResult,
+)
+
+__all__ = [
+    "BenchmarkCase",
+    "BenchmarkFile",
+    "BenchmarkResult",
+    "BenchmarkRunConfig",
+    "CaseTrace",
+    "ScoreResult",
+]

mindcode/bench/adapters/__init__.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from .base import BenchmarkAdapter
+from .mini_bfcl import MiniBfclAdapter
+from .mini_gaia import MiniGaiaAdapter
+from .mini_terminal import MiniTerminalAdapter
+from .swe_bench import SWEBenchAdapter
+from .terminal_bench import TerminalBenchAdapter
+
+
+def built_in_adapters() -> dict[str, BenchmarkAdapter]:
+    adapters: list[BenchmarkAdapter] = [
+        MiniBfclAdapter(),
+        MiniTerminalAdapter(),
+        MiniGaiaAdapter(),
+        SWEBenchAdapter(),
+        TerminalBenchAdapter(),
+    ]
+    return {adapter.suite: adapter for adapter in adapters}
+
+
+__all__ = ["BenchmarkAdapter", "built_in_adapters"]

mindcode/bench/adapters/base.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Protocol
+
+from ..schema import BenchmarkCase, BenchmarkFile
+from ..scorers.base import Scorer
+
+
+class BenchmarkAdapter(Protocol):
+    suite: str
+
+    def load_cases(self, root: Path) -> list[BenchmarkCase]: ...
+
+    def build_scorer(self) -> Scorer: ...
+
+
+def load_jsonl_cases(path: Path, suite: str) -> list[BenchmarkCase]:
+    cases: list[BenchmarkCase] = []
+    with path.open(encoding="utf-8") as file:
+        for line_number, line in enumerate(file, start=1):
+            if not line.strip():
+                continue
+            raw = json.loads(line)
+            files = tuple(
+                BenchmarkFile(path=item["path"], content=item["content"])
+                for item in raw.get("files", [])
+            )
+            cases.append(
+                BenchmarkCase(
+                    case_id=str(raw["case_id"]),
+                    suite=str(raw.get("suite", suite)),
+                    category=str(raw.get("category", "uncategorized")),
+                    prompt=str(raw["prompt"]),
+                    expected=raw.get("expected"),
+                    files=files,
+                    tools=tuple(raw.get("tools", []) or ()),
+                    metadata={
+                        **dict(raw.get("metadata", {}) or {}),
+                        "source_line": line_number,
+                    },
+                )
+            )
+    return cases

mindcode/bench/adapters/mini_bfcl.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from ..schema import BenchmarkCase
+from ..scorers.base import Scorer
+from ..scorers.json_call import JsonToolCallScorer
+from .base import load_jsonl_cases
+
+
+class MiniBfclAdapter:
+    suite = "mini_bfcl"
+
+    def load_cases(self, root: Path) -> list[BenchmarkCase]:
+        return load_jsonl_cases(root / self.suite / "cases.jsonl", self.suite)
+
+    def build_scorer(self) -> Scorer:
+        return JsonToolCallScorer()

mindcode/bench/adapters/mini_gaia.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from ..schema import BenchmarkCase
+from ..scorers.base import Scorer
+from ..scorers.exact import ExactAnswerScorer
+from .base import load_jsonl_cases
+
+
+class MiniGaiaAdapter:
+    suite = "mini_gaia"
+
+    def load_cases(self, root: Path) -> list[BenchmarkCase]:
+        return load_jsonl_cases(root / self.suite / "cases.jsonl", self.suite)
+
+    def build_scorer(self) -> Scorer:
+        return ExactAnswerScorer()

mindcode/bench/adapters/mini_terminal.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from ..schema import BenchmarkCase
+from ..scorers.base import Scorer
+from ..scorers.terminal import FileStateScorer
+from .base import load_jsonl_cases
+
+
+class MiniTerminalAdapter:
+    suite = "mini_terminal"
+
+    def load_cases(self, root: Path) -> list[BenchmarkCase]:
+        return load_jsonl_cases(root / self.suite / "cases.jsonl", self.suite)
+
+    def build_scorer(self) -> Scorer:
+        return FileStateScorer()

mindcode/bench/adapters/swe_bench.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from ..schema import BenchmarkCase, BenchmarkFile
+from ..scorers.base import Scorer
+from ..scorers.swe import PatchGeneratedScorer
+
+
+class SWEBenchAdapter:
+    suite = "swe_bench"
+
+    def load_cases(self, root: Path) -> list[BenchmarkCase]:
+        path = root if root.is_file() else root / self.suite / "cases.jsonl"
+        return [_case_from_raw(raw) for raw in _load_rows(path)]
+
+    def build_scorer(self) -> Scorer:
+        return PatchGeneratedScorer()
+
+
+def _load_rows(path: Path) -> list[dict[str, Any]]:
+    if path.suffix == ".json":
+        data = json.loads(path.read_text(encoding="utf-8"))
+        if isinstance(data, dict):
+            data = list(data.values())
+        if not isinstance(data, list):
+            raise ValueError("SWE-bench JSON dataset must be a list or dict")
+        return [dict(item) for item in data]
+    with path.open(encoding="utf-8") as file:
+        return [json.loads(line) for line in file if line.strip()]
+
+
+def _case_from_raw(raw: dict[str, Any]) -> BenchmarkCase:
+    instance_id = str(raw["instance_id"])
+    problem = str(raw.get("problem_statement") or raw.get("text") or "")
+    prompt = _build_prompt(raw, problem)
+    files = tuple(
+        BenchmarkFile(path=str(item["path"]), content=str(item["content"]))
+        for item in raw.get("files", []) or []
+    )
+    metadata = {
+        key: raw.get(key)
+        for key in (
+            "repo",
+            "base_commit",
+            "version",
+            "patch",
+            "test_patch",
+            "FAIL_TO_PASS",
+            "PASS_TO_PASS",
+        )
+        if key in raw
+    }
+    return BenchmarkCase(
+        case_id=instance_id,
+        suite="swe_bench",
+        category=str(raw.get("category", "swe_issue")),
+        prompt=prompt,
+        expected={"gold_patch": raw.get("patch")},
+        files=files,
+        metadata=metadata,
+    )
+
+
+def _build_prompt(raw: dict[str, Any], problem: str) -> str:
+    repo = raw.get("repo", "")
+    base_commit = raw.get("base_commit", "")
+    hints = raw.get("hints_text", "")
+    parts = [
+        "You are solving a SWE-bench task.",
+        "Inspect and edit the repository files in the workspace.",
+        "When done, ensure the workspace diff is the patch for the fix.",
+        "Do not include unrelated changes.",
+        "",
+        f"instance_id: {raw['instance_id']}",
+    ]
+    if repo:
+        parts.append(f"repo: {repo}")
+    if base_commit:
+        parts.append(f"base_commit: {base_commit}")
+    parts.extend(["", "Problem statement:", problem])
+    if hints:
+        parts.extend(["", "Hints:", str(hints)])
+    return "\n".join(parts).strip()

mindcode/bench/adapters/terminal_bench.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from ..paths import DEFAULT_TERMINAL_BENCH_ROOT
+from ..schema import BenchmarkCase, BenchmarkFile
+from ..scorers.base import Scorer
+from ..scorers.terminal_bench import TerminalBenchRunScorer
+
+
+class TerminalBenchAdapter:
+    suite = "terminal_bench"
+
+    def load_cases(self, root: Path) -> list[BenchmarkCase]:
+        jsonl_path = root / self.suite / "cases.jsonl"
+        if jsonl_path.exists():
+            return [_case_from_json(raw) for raw in _load_jsonl(jsonl_path)]
+        tasks_root = DEFAULT_TERMINAL_BENCH_ROOT / "original-tasks"
+        return [
+            _case_from_task_dir(task_dir)
+            for task_dir in sorted(tasks_root.iterdir())
+            if (task_dir / "task.yaml").exists()
+        ]
+
+    def build_scorer(self) -> Scorer:
+        return TerminalBenchRunScorer()
+
+
+def _load_jsonl(path: Path) -> list[dict[str, Any]]:
+    with path.open(encoding="utf-8") as file:
+        return [json.loads(line) for line in file if line.strip()]
+
+
+def _case_from_json(raw: dict[str, Any]) -> BenchmarkCase:
+    files = tuple(
+        BenchmarkFile(path=str(item["path"]), content=str(item["content"]))
+        for item in raw.get("files", []) or []
+    )
+    return BenchmarkCase(
+        case_id=str(raw["case_id"]),
+        suite="terminal_bench",
+        category=str(raw.get("category", "terminal_task")),
+        prompt=str(raw["prompt"]),
+        expected=raw.get("expected"),
+        files=files,
+        metadata=dict(raw.get("metadata", {}) or {}),
+    )
+
+
+def _case_from_task_dir(task_dir: Path) -> BenchmarkCase:
+    task = yaml.safe_load((task_dir / "task.yaml").read_text(encoding="utf-8"))
+    files = tuple(_iter_visible_files(task_dir))
+    instruction = str(task["instruction"])
+    prompt = (
+        "You are solving a Terminal-Bench task in this workspace.\n"
+        "Use shell and file tools as needed. Do not look for solution files.\n"
+        "When finished, leave the workspace in the solved state and summarize "
+        "what you changed.\n\n"
+        f"task_id: {task_dir.name}\n\n"
+        f"Instruction:\n{instruction}"
+    )
+    return BenchmarkCase(
+        case_id=task_dir.name,
+        suite="terminal_bench",
+        category=str(task.get("category", "terminal_task")),
+        prompt=prompt,
+        expected=None,
+        files=files,
+        metadata={
+            "task_path": str(task_dir),
+            "difficulty": task.get("difficulty"),
+            "tags": task.get("tags", []),
+            "parser_name": task.get("parser_name"),
+            "max_agent_timeout_sec": task.get("max_agent_timeout_sec"),
+            "max_test_timeout_sec": task.get("max_test_timeout_sec"),
+        },
+    )
+
+
+def _iter_visible_files(task_dir: Path) -> list[BenchmarkFile]:
+    files: list[BenchmarkFile] = []
+    excluded_names = {
+        "solution.sh",
+        "solution.yaml",
+        "task.yaml",
+        "run-tests.sh",
+        "docker-compose.yaml",
+        "Dockerfile",
+    }
+    for path in sorted(task_dir.rglob("*")):
+        if not path.is_file():
+            continue
+        rel = path.relative_to(task_dir)
+        if rel.parts[0] == "tests" or path.name in excluded_names:
+            continue
+        try:
+            if path.stat().st_size > 1_000_000:
+                continue
+            content = path.read_text(encoding="utf-8")
+        except UnicodeDecodeError:
+            continue
+        files.append(BenchmarkFile(path=rel.as_posix(), content=content))
+    return files

mindcode/bench/fake_tools.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from typing import Any
+
+from mindagent.core import ActionRisk
+from mindagent.tools.base import BaseTool, ToolContext, ToolDefinition
+
+from .schema import BenchmarkCase
+
+
+class FakeBenchmarkTool(BaseTool):
+    def __init__(self, name: str, parameters: dict[str, Any]):
+        self.definition = ToolDefinition(
+            name=name,
+            description=f"Benchmark fake tool: {name}",
+            parameters=parameters,
+            risk=ActionRisk.READ_ONLY,
+        )
+
+    async def execute(
+        self,
+        arguments: dict[str, Any],
+        context: ToolContext,
+    ) -> dict[str, Any]:
+        return {"ok": True, "tool": self.definition.name, "arguments": arguments}
+
+
+def build_fake_tools(case: BenchmarkCase) -> list[FakeBenchmarkTool]:
+    names = list(case.tools)
+    expected = case.expected if isinstance(case.expected, dict) else {}
+    for call in expected.get("tool_calls", []):
+        name = call.get("name")
+        if name and name not in names:
+            names.append(name)
+
+    expected_args_by_name = {
+        call.get("name"): call.get("arguments", {})
+        for call in expected.get("tool_calls", [])
+        if isinstance(call, dict)
+    }
+    return [
+        FakeBenchmarkTool(
+            name,
+            _parameters_from_arguments(expected_args_by_name.get(name, {})),
+        )
+        for name in names
+    ]
+
+
+def _parameters_from_arguments(arguments: dict[str, Any]) -> dict[str, Any]:
+    properties = {
+        key: _schema_for_value(value) for key, value in arguments.items()
+    }
+    return {
+        "type": "object",
+        "properties": properties,
+        "required": list(properties),
+        "additionalProperties": False,
+    }
+
+
+def _schema_for_value(value: Any) -> dict[str, Any]:
+    if isinstance(value, bool):
+        return {"type": "boolean"}
+    if isinstance(value, int):
+        return {"type": "integer"}
+    if isinstance(value, float):
+        return {"type": "number"}
+    if isinstance(value, list):
+        return {"type": "array"}
+    if isinstance(value, dict):
+        return {"type": "object"}
+    return {"type": "string"}

mindcode/bench/jsonutil.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from dataclasses import asdict, is_dataclass
+from enum import Enum
+from pathlib import Path
+from typing import Any
+
+
+def to_jsonable(value: Any) -> Any:
+    if isinstance(value, Enum):
+        return value.value
+    if isinstance(value, Path):
+        return str(value)
+    if is_dataclass(value):
+        return {key: to_jsonable(item) for key, item in asdict(value).items()}
+    if isinstance(value, dict):
+        return {str(key): to_jsonable(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [to_jsonable(item) for item in value]
+    return value

mindcode/bench/paths.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+
+PACKAGE_ROOT = Path(__file__).resolve().parents[1]
+APP_ROOT = PACKAGE_ROOT.parent
+DEFAULT_BENCHMARK_ROOT = APP_ROOT / "benchmarks"
+DEFAULT_RUNS_ROOT = APP_ROOT / "bench_runs"
+DEFAULT_TERMINAL_BENCH_ROOT = APP_ROOT.parent / "lib" / "terminal-bench"