mindcode 0.2.0__py3-none-any.whl

mindcode/cli/commands/bench.py

@@ -0,0 +1,365 @@
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+import typer
+from rich.table import Table
+
+from mindagent.core.artifact import (
+    ArtifactPathError,
+    ensure_artifact_directory,
+    validate_artifact_path,
+)
+
+from ...bench.paths import (
+    DEFAULT_BENCHMARK_ROOT,
+    DEFAULT_RUNS_ROOT,
+    DEFAULT_TERMINAL_BENCH_ROOT,
+    APP_ROOT,
+)
+from ...bench.report import build_summary
+from ...bench.runner import (
+    MindcodeBenchmarkRunner,
+    _case_trace_path,
+    _run_output_dir,
+    run_benchmark,
+)
+from ...bench.schema import BenchmarkRunConfig
+from ...config import load_config
+from ...policy import ApprovalMode
+from .._shared import console
+
+
+app = typer.Typer(help="运行 mindcode benchmark")
+
+
+@app.command("list")
+def list_suites(
+    benchmark_root: str = typer.Option(
+        str(DEFAULT_BENCHMARK_ROOT),
+        "--benchmark-root",
+        help="benchmark case 根目录",
+    ),
+) -> None:
+    runner = MindcodeBenchmarkRunner(Path(benchmark_root).expanduser().resolve())
+    table = Table("suite", "cases")
+    for suite, count in runner.list_suites():
+        table.add_row(suite, str(count))
+    console.print(table)
+
+
+@app.command("run")
+def run(
+    suite: str = typer.Option(..., "--suite", help="要运行的 suite"),
+    limit: int | None = typer.Option(None, "--limit", help="限制 case 数"),
+    case_ids: list[str] | None = typer.Option(
+        None,
+        "--case",
+        help="指定 case id，可重复",
+    ),
+    provider: str | None = typer.Option(
+        None,
+        "-p",
+        "--provider",
+        help="覆盖 default_provider",
+    ),
+    model: str | None = typer.Option(None, "--model", help="覆盖模型"),
+    approve_mode: str = typer.Option(
+        ApprovalMode.FULL_ACCEPT.value,
+        "--approve-mode",
+        case_sensitive=False,
+        help="权限模式：ask_user 逐项询问，full_accept 全部接受",
+    ),
+    output: str = typer.Option(
+        str(DEFAULT_RUNS_ROOT),
+        "--output",
+        help="run 输出目录",
+    ),
+    benchmark_root: str = typer.Option(
+        str(DEFAULT_BENCHMARK_ROOT),
+        "--benchmark-root",
+        help="benchmark case 根目录",
+    ),
+    max_steps: int = typer.Option(50, "--max-steps", help="每 case 最大 step"),
+    total_timeout: float | None = typer.Option(
+        600.0,
+        "--total-timeout",
+        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:
+        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,
+            workspace_root=run_output_dir / "workspaces",
+            output_root=output_root,
+            limit=limit,
+            case_ids=tuple(case_ids or ()),
+            max_steps=max_steps,
+            total_timeout_s=total_timeout,
+        )
+        results = run_benchmark(
+            run_config,
+            Path(benchmark_root).expanduser().resolve(),
+        )
+    except ValueError as exc:
+        console.print(f"[red]benchmark 配置错误:[/red] {exc}")
+        raise typer.Exit(2)
+
+    summary = build_summary(results)
+    console.print(
+        f"run_id={run_id} passed={summary['passed']}/{summary['total']} "
+        f"pass_rate={summary['pass_rate']:.1%}"
+    )
+    console.print(f"output={run_output_dir}")
+
+
+@app.command("report")
+def report(
+    run_id: str,
+    output: str = typer.Option(
+        str(DEFAULT_RUNS_ROOT),
+        "--output",
+        help="run 输出目录",
+    ),
+) -> None:
+    output_root = Path(output).expanduser()
+    try:
+        summary_path = validate_artifact_path(
+            output_root,
+            _run_output_dir(output_root, run_id) / "summary.json",
+        )
+    except ArtifactPathError as exc:
+        console.print(f"[red]artifact 路径非法:[/red] {exc}")
+        raise typer.Exit(2)
+    if not summary_path.exists():
+        console.print(f"[red]summary 不存在:[/red] {summary_path}")
+        raise typer.Exit(2)
+    summary = json.loads(summary_path.read_text(encoding="utf-8"))
+    console.print(
+        f"passed={summary['passed']}/{summary['total']} "
+        f"pass_rate={summary['pass_rate']:.1%} "
+        f"avg_latency_s={summary['avg_latency_s']:.2f}"
+    )
+    if summary["failed_cases"]:
+        table = Table("case", "score", "phase", "reason")
+        for item in summary["failed_cases"]:
+            table.add_row(
+                item["case_id"],
+                str(item["score"]),
+                str(item.get("failure_phase")),
+                str(item.get("failure_reason")),
+            )
+        console.print(table)
+
+
+@app.command("inspect")
+def inspect(
+    run_id: str,
+    case_id: str,
+    output: str = typer.Option(
+        str(DEFAULT_RUNS_ROOT),
+        "--output",
+        help="run 输出目录",
+    ),
+) -> None:
+    output_root = Path(output).expanduser()
+    try:
+        trace_path = _case_trace_path(
+            _run_output_dir(output_root, run_id) / "traces",
+            case_id,
+        )
+        validate_artifact_path(output_root, trace_path)
+    except ArtifactPathError as exc:
+        console.print(f"[red]artifact 路径非法:[/red] {exc}")
+        raise typer.Exit(2)
+    if not trace_path.exists():
+        console.print(f"[red]trace 不存在:[/red] {trace_path}")
+        raise typer.Exit(2)
+    trace = json.loads(trace_path.read_text(encoding="utf-8"))
+    result = trace["result"]
+    console.print(f"case={case_id} passed={result['passed']} score={result['score']}")
+    console.print(f"final_answer={result.get('final_answer')}")
+    console.print(f"expected={trace['case'].get('expected')}")
+    console.print(f"tool_calls={len(trace.get('tool_calls', []))}")
+    if trace.get("failure_analysis"):
+        console.print(f"failure={trace['failure_analysis']}")
+
+
+@app.command("swe-eval")
+def swe_eval(
+    predictions_path: str = typer.Option(
+        ...,
+        "--predictions-path",
+        help="SWE-bench predictions.jsonl 路径",
+    ),
+    dataset_name: str = typer.Option(
+        "SWE-bench/SWE-bench_Lite",
+        "--dataset-name",
+        help="SWE-bench dataset 名称或本地 json/jsonl/parquet 路径",
+    ),
+    split: str = typer.Option("test", "--split", help="dataset split"),
+    run_id: str = typer.Option(
+        None,
+        "--run-id",
+        help="SWE-bench evaluation run id",
+    ),
+    max_workers: int = typer.Option(1, "--max-workers", help="并发 worker 数"),
+    timeout: int | None = typer.Option(
+        None,
+        "--timeout",
+        help="单实例评测超时秒数",
+    ),
+    swebench_path: str = typer.Option(
+        str(APP_ROOT.parent / "lib" / "SWE-bench"),
+        "--swebench-path",
+        help="本地 SWE-bench 仓库路径",
+    ),
+) -> None:
+    predictions = Path(predictions_path).expanduser().resolve()
+    if not predictions.exists():
+        console.print(f"[red]predictions 不存在:[/red] {predictions}")
+        raise typer.Exit(2)
+    swebench = Path(swebench_path).expanduser().resolve()
+    if not (swebench / "swebench").is_dir():
+        console.print(f"[red]SWE-bench 路径无效:[/red] {swebench}")
+        raise typer.Exit(2)
+
+    eval_run_id = run_id or f"mindcode-{time.strftime('%Y%m%d-%H%M%S')}"
+    cmd = [
+        sys.executable,
+        "-m",
+        "swebench.harness.run_evaluation",
+        "--dataset_name",
+        dataset_name,
+        "--split",
+        split,
+        "--predictions_path",
+        str(predictions),
+        "--max_workers",
+        str(max_workers),
+        "--run_id",
+        eval_run_id,
+    ]
+    if timeout is not None:
+        cmd.extend(["--timeout", str(timeout)])
+
+    env = os.environ.copy()
+    existing = env.get("PYTHONPATH")
+    env["PYTHONPATH"] = (
+        str(swebench) if not existing else str(swebench) + os.pathsep + existing
+    )
+    console.print(" ".join(cmd))
+    result = subprocess.run(cmd, cwd=swebench, env=env)
+    raise typer.Exit(result.returncode)
+
+
+@app.command("terminal-eval")
+def terminal_eval(
+    dataset_path: str = typer.Option(
+        str(DEFAULT_TERMINAL_BENCH_ROOT / "original-tasks"),
+        "--dataset-path",
+        help="Terminal-Bench dataset/task 目录",
+    ),
+    task_ids: list[str] | None = typer.Option(
+        None,
+        "--task-id",
+        help="指定 task id，可重复",
+    ),
+    agent: str = typer.Option(
+        "oracle",
+        "--agent",
+        "-a",
+        help="Terminal-Bench agent 名称",
+    ),
+    model: str | None = typer.Option(
+        None,
+        "--model",
+        "-m",
+        help="Terminal-Bench agent 使用的模型名",
+    ),
+    output: str = typer.Option(
+        str(DEFAULT_TERMINAL_BENCH_ROOT / "runs"),
+        "--output",
+        help="Terminal-Bench run 输出目录",
+    ),
+    run_id: str | None = typer.Option(
+        None,
+        "--run-id",
+        help="Terminal-Bench run id",
+    ),
+    n_concurrent: int = typer.Option(
+        1,
+        "--n-concurrent",
+        help="并发 trial 数",
+    ),
+    n_attempts: int = typer.Option(
+        1,
+        "--n-attempts",
+        help="每个 task 尝试次数",
+    ),
+    no_rebuild: bool = typer.Option(
+        False,
+        "--no-rebuild",
+        help="跳过重建容器",
+    ),
+) -> None:
+    tb_cmd = shutil.which("tb") or shutil.which("terminal-bench")
+    if tb_cmd is None:
+        console.print("[red]未找到 Terminal-Bench CLI:[/red] 请先安装 tb")
+        raise typer.Exit(2)
+    dataset = Path(dataset_path).expanduser().resolve()
+    if not dataset.exists():
+        console.print(f"[red]dataset_path 不存在:[/red] {dataset}")
+        raise typer.Exit(2)
+
+    output_path = Path(output).expanduser()
+    try:
+        ensure_artifact_directory(output_path)
+    except ArtifactPathError as exc:
+        console.print(f"[red]artifact 输出路径非法:[/red] {exc}")
+        raise typer.Exit(2)
+
+    cmd = [
+        tb_cmd,
+        "run",
+        "--dataset-path",
+        str(dataset),
+        "--agent",
+        agent,
+        "--output-path",
+        str(output_path),
+        "--n-concurrent",
+        str(n_concurrent),
+        "--n-attempts",
+        str(n_attempts),
+    ]
+    if model:
+        cmd.extend(["--model", model])
+    if run_id:
+        cmd.extend(["--run-id", run_id])
+    if no_rebuild:
+        cmd.append("--no-rebuild")
+    for task_id in task_ids or ():
+        cmd.extend(["--task-id", task_id])
+
+    console.print(
+        f"Terminal-Bench run: agent={agent} "
+        f"tasks={','.join(task_ids or ['all'])} output={output_path}"
+    )
+    result = subprocess.run(cmd)
+    raise typer.Exit(result.returncode)

mindcode/cli/commands/chat.py

@@ -0,0 +1,86 @@
+"""`mindcode chat` 子命令 —— 一次性 prompt 模式。"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+from ...policy import ApprovalMode
+from .._shared import console
+from ..shell import run_shell
+
+
+def chat(
+    message: str = typer.Option(
+        None, "--message", "-m", help="要发送的消息"
+    ),
+    workspace: str = typer.Option(
+        ".", "-w", "--workspace", help="workspace 根目录"
+    ),
+    approve_mode: str = typer.Option(
+        ApprovalMode.FULL_ACCEPT.value,
+        "-a",
+        "--approve-mode",
+        case_sensitive=False,
+        help="权限模式：ask_user 逐项询问，full_accept 全部接受",
+    ),
+    provider: str = typer.Option(
+        None, "-p", "--provider", help="覆盖 default_provider"
+    ),
+    model: str = typer.Option(
+        None, "--model", help="覆盖 default_model",
+    ),
+    session: str = typer.Option(
+        None, "-s", "--session", help="指定 session_id"
+    ),
+    resume: str = typer.Option(
+        None, "-r", "--resume", help="恢复 session_id 后追加"
+    ),
+    no_stream: bool = typer.Option(
+        False, "--no-stream", help="关闭流式输出"
+    ),
+    max_steps: int | None = typer.Option(
+        None, "--max-steps", help="最大 step 数（默认 50）"
+    ),
+    step_timeout: float | None = typer.Option(
+        None, "--step-timeout", help="单步超时秒数，0 表示禁用（默认 120）"
+    ),
+    total_timeout: float | None = typer.Option(
+        None, "--total-timeout", help="总超时秒数，0 表示禁用（默认 600）"
+    ),
+) -> None:
+    """发送单条消息，不进入交互模式。"""
+    if not message:
+        console.print("[red]Error:[/red] --message is required")
+        raise typer.Exit(1)
+
+    ws = Path(workspace).expanduser().resolve()
+    if not ws.is_dir():
+        console.print(
+            f"[red]workspace 不存在或不是目录:[/red] {ws}"
+        )
+        raise typer.Exit(2)
+
+    try:
+        rc = run_shell(
+            ws,
+            approve_mode=ApprovalMode(approve_mode),
+            provider_name=provider,
+            model=model,
+            session_id=session,
+            resume=resume,
+            stream=not no_stream,
+            one_shot_prompt=message,
+            max_steps=max_steps if max_steps is not None else 50,
+            step_timeout_s=None
+            if step_timeout == 0
+            else (step_timeout if step_timeout is not None else 300.0),
+            total_timeout_s=None
+            if total_timeout == 0
+            else (total_timeout if total_timeout is not None else 1800.0),
+        )
+    except ValueError as exc:
+        console.print(f"[red]配置错误:[/red] {exc}")
+        raise typer.Exit(2)
+    raise typer.Exit(rc)

mindcode/cli/commands/config_cmd.py

@@ -0,0 +1,197 @@
+"""`mindcode config` 子命令 —— 配置管理（typer app）。"""
+
+from __future__ import annotations
+
+import typer
+from rich.markup import escape
+from rich.table import Table
+
+from ...config import (
+    CONFIG_FILE,
+    load_config,
+    save_config,
+)
+from .._shared import console, mask_key
+
+app = typer.Typer(help="配置管理（providers / models / api-key）")
+
+
+@app.command("providers")
+def config_providers() -> None:
+    """列出所有 provider。"""
+    config = load_config()
+    table = Table(
+        title=f"Providers ({CONFIG_FILE})",
+        show_header=True,
+        header_style="bold cyan",
+    )
+    table.add_column("", width=3)
+    table.add_column("Provider", style="cyan")
+    table.add_column("Protocol")
+    table.add_column("Key")
+    table.add_column("Base URL", style="dim")
+    table.add_column("Default Model", style="green")
+
+    for name, p in config.providers.items():
+        mark = "[green]*[/green]" if name == config.default_provider else " "
+        table.add_row(
+            mark,
+            name,
+            p.protocol,
+            mask_key(p.api_key),
+            p.base_url,
+            p.default_model,
+        )
+
+    console.print(table)
+
+
+@app.command("models")
+def config_models(
+    provider: str = typer.Argument(..., help="provider 名称"),
+) -> None:
+    """列出指定 provider 的所有 model。"""
+    config = load_config()
+    if provider not in config.providers:
+        console.print(
+            f"[red]未知 provider:[/red] {provider}  "
+            f"[dim]可用: {', '.join(config.providers)}[/dim]"
+        )
+        raise typer.Exit(1)
+    p = config.providers[provider]
+    console.print(
+        f"[bold cyan]{provider}[/bold cyan]  "
+        f"[dim]{p.protocol} {p.base_url}[/dim]"
+    )
+    for m in p.models:
+        mark = (
+            "[green]*[/green]" if m == p.default_model else " "
+        )
+        console.print(f" {mark} {m}")
+
+
+@app.command("api-key")
+def config_api_key(
+    provider: str = typer.Argument(..., help="provider 名称"),
+    key: str = typer.Argument(..., help="api_key"),
+) -> None:
+    """设置 provider 的 api_key（持久化）。"""
+    config = load_config()
+    if provider not in config.providers:
+        console.print(
+            f"[red]未知 provider:[/red] {provider}  "
+            f"[dim]可用: {', '.join(config.providers)}[/dim]"
+        )
+        raise typer.Exit(1)
+    config.providers[provider].api_key = key.strip()
+    save_config(config)
+    console.print(
+        f"[green]✓[/green] 已保存 [cyan]{provider}[/cyan] 的 api_key "
+        f"({mask_key(key.strip())})"
+    )
+
+
+@app.command("get")
+def config_get(
+    provider: str = typer.Argument(..., help="provider 名称"),
+    key: str = typer.Argument(
+        ..., help="字段名：protocol / api_key / base_url / default_model / models"
+    ),
+) -> None:
+    """读取 provider 的某个字段。"""
+    config = load_config()
+    if provider not in config.providers:
+        console.print(f"[red]未知 provider:[/red] {provider}")
+        raise typer.Exit(1)
+    p = config.providers[provider]
+    valid_keys = {"protocol", "api_key", "base_url", "default_model", "models"}
+    if key not in valid_keys:
+        console.print(
+            f"[red]未知字段:[/red] {key}  [dim]可用: {', '.join(valid_keys)}[/dim]"
+        )
+        raise typer.Exit(1)
+    value = getattr(p, key)
+    if key == "api_key":
+        value = mask_key(p.api_key)
+    console.print(f"[green]{provider}.{key}[/green] = {value}")
+
+
+@app.command("set")
+def config_set(
+    provider: str = typer.Argument(..., help="provider 名称"),
+    key: str = typer.Argument(
+        ..., help="字段名：protocol / base_url / default_model / api_key"
+    ),
+    value: str = typer.Argument(..., help="字段值"),
+) -> None:
+    """修改 provider 的某个字段（持久化）。"""
+    config = load_config()
+    if provider not in config.providers:
+        console.print(f"[red]未知 provider:[/red] {provider}")
+        raise typer.Exit(1)
+    p = config.providers[provider]
+    valid_keys = {"protocol", "api_key", "base_url", "default_model"}
+    if key not in valid_keys:
+        console.print(
+            f"[red]未知字段:[/red] {key}  "
+            f"[dim]可 set: {', '.join(valid_keys)}[/dim]"
+        )
+        raise typer.Exit(1)
+    setattr(p, key, value)
+    if key == "protocol" and value not in {"openai", "anthropic"}:
+        console.print(f"[red]配置错误:[/red] 不支持的 protocol: {value}")
+        raise typer.Exit(2)
+    save_config(config)
+    console.print(
+        f"[green]✓[/green] {provider}.{key} = "
+        f"{(mask_key(value) if key == 'api_key' else value)}"
+    )
+
+
+@app.command("models-set")
+def config_models_set(
+    provider: str = typer.Argument(..., help="provider 名称"),
+    models: list[str] = typer.Argument(..., help="模型列表"),
+) -> None:
+    """设置 provider 的 model_list；第一个模型会成为 default_model。"""
+    config = load_config()
+    if provider not in config.providers:
+        console.print(f"[red]未知 provider:[/red] {provider}")
+        raise typer.Exit(1)
+    cleaned = [model.strip() for model in models if model.strip()]
+    if not cleaned:
+        console.print("[red]models 不能为空[/red]")
+        raise typer.Exit(2)
+    config.providers[provider].models = cleaned
+    config.providers[provider].default_model = cleaned[0]
+    save_config(config)
+    console.print(
+        f"[green]✓[/green] {provider}.models = {', '.join(cleaned)}"
+    )
+
+
+@app.command("list")
+def config_list() -> None:
+    """显示完整配置（脱敏）。"""
+    config = load_config()
+    console.print(f"[dim]# {CONFIG_FILE}[/dim]")
+    console.print(f'default_provider = "{config.default_provider}"\n')
+    for name, p in config.providers.items():
+        console.print(f"[bold]{escape(f'[providers.{name}]')}[/bold]")
+        console.print(f"  protocol      = [cyan]{p.protocol}[/cyan]")
+        console.print(f"  api_key       = {mask_key(p.api_key)}")
+        console.print(f"  base_url      = [dim]{p.base_url}[/dim]")
+        console.print(f"  default_model = [green]{p.default_model}[/green]")
+        if p.models:
+            console.print(f"  models        = {', '.join(p.models)}")
+        console.print()
+
+
+@app.command("path")
+def config_path() -> None:
+    """显示配置文件路径。"""
+    console.print(str(CONFIG_FILE))
+
+
+if __name__ == "__main__":
+    app()