mindcode 0.2.0__py3-none-any.whl

mindcode/cli/commands/remote.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import typer
+from rich.table import Table
+
+from ...remote import (
+    RemoteConfig,
+    RemoteExecutor,
+    RemoteStore,
+    SSHCommandBuilder,
+    mask_env,
+)
+from .._shared import console
+
+
+app = typer.Typer(help="管理和执行远程 SSH 目标")
+
+
+@app.command("add")
+def add_remote(
+    name: str = typer.Argument(..., help="remote 名称"),
+    host: str = typer.Option(..., "--host", help="SSH host，允许 user@host"),
+    workdir: str = typer.Option(..., "--workdir", help="远程默认工作目录"),
+    port: int = typer.Option(22, "--port", help="SSH 端口"),
+    identity_file: str | None = typer.Option(
+        None,
+        "--identity-file",
+        help="SSH 私钥路径",
+    ),
+    env: list[str] | None = typer.Option(
+        None,
+        "--env",
+        help="环境变量，格式 KEY=VALUE，可重复",
+    ),
+) -> None:
+    try:
+        config = RemoteConfig(
+            name=name,
+            host=host,
+            port=port,
+            workdir=workdir,
+            identity_file=str(Path(identity_file).expanduser()) if identity_file else None,
+            env=_parse_env(env or []),
+        )
+        RemoteStore().add(config)
+    except ValueError as exc:
+        console.print(f"[red]remote 配置错误:[/red] {exc}")
+        raise typer.Exit(2)
+    console.print(f"remote added: {name}")
+
+
+@app.command("list")
+def list_remotes() -> None:
+    table = Table("name", "host", "port", "workdir")
+    for config in RemoteStore().load_all().values():
+        table.add_row(config.name, config.host, str(config.port), config.workdir)
+    console.print(table)
+
+
+@app.command("show")
+def show_remote(name: str) -> None:
+    try:
+        config = RemoteStore().get(name)
+    except KeyError:
+        console.print(f"[red]remote 不存在:[/red] {name}")
+        raise typer.Exit(2)
+    payload = {
+        "name": config.name,
+        "host": config.host,
+        "port": config.port,
+        "workdir": config.workdir,
+        "identity_file": config.identity_file,
+        "env": mask_env(config.env),
+    }
+    console.print(json.dumps(payload, ensure_ascii=False, indent=2))
+
+
+@app.command("remove")
+def remove_remote(name: str) -> None:
+    if not RemoteStore().remove(name):
+        console.print(f"[red]remote 不存在:[/red] {name}")
+        raise typer.Exit(2)
+    console.print(f"remote removed: {name}")
+
+
+@app.command("exec")
+def exec_remote(
+    name: str = typer.Argument(..., help="remote 名称"),
+    command: str = typer.Argument(..., help="远程 shell 命令"),
+    timeout: float | None = typer.Option(None, "--timeout", help="超时秒数"),
+) -> None:
+    try:
+        config = RemoteStore().get(name)
+    except KeyError:
+        console.print(f"[red]remote 不存在:[/red] {name}")
+        raise typer.Exit(2)
+    result = RemoteExecutor().execute(config, command, timeout_s=timeout)
+    if result.stdout:
+        console.print(result.stdout, end="")
+    if result.stderr:
+        console.print(result.stderr, end="", style="red")
+    if result.exit_code != 0:
+        raise typer.Exit(result.exit_code)
+
+
+@app.command("tail")
+def tail_remote(
+    name: str = typer.Argument(..., help="remote 名称"),
+    path: str = typer.Argument(..., help="远程日志路径"),
+    lines: int = typer.Option(80, "--lines", "-n", help="显示最近行数"),
+    follow: bool = typer.Option(False, "--follow", "-f", help="持续追踪"),
+    timeout: float | None = typer.Option(None, "--timeout", help="超时秒数"),
+) -> None:
+    try:
+        config = RemoteStore().get(name)
+        command = SSHCommandBuilder().build_tail_command(
+            path,
+            lines=lines,
+            follow=follow,
+        )
+    except KeyError:
+        console.print(f"[red]remote 不存在:[/red] {name}")
+        raise typer.Exit(2)
+    except ValueError as exc:
+        console.print(f"[red]tail 参数错误:[/red] {exc}")
+        raise typer.Exit(2)
+    result = RemoteExecutor().execute(config, command, timeout_s=timeout)
+    if result.stdout:
+        console.print(result.stdout, end="")
+    if result.stderr:
+        console.print(result.stderr, end="", style="red")
+    if result.exit_code != 0:
+        raise typer.Exit(result.exit_code)
+
+
+def _parse_env(items: list[str]) -> dict[str, str]:
+    parsed: dict[str, str] = {}
+    for item in items:
+        if "=" not in item:
+            raise ValueError(f"--env must be KEY=VALUE: {item}")
+        key, value = item.split("=", 1)
+        parsed[key] = value
+    return parsed

mindcode/cli/commands/shell.py

@@ -0,0 +1,108 @@
+"""`mindcode shell` 子命令 —— 交互式 REPL 入口。"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+from ...policy import ApprovalMode
+from .._shared import console
+from ..shell import run_shell
+
+
+_SHELL_APPROVAL_MODES = {
+    "ask_user": ApprovalMode.ASK_USER,
+    "full_accept": ApprovalMode.FULL_ACCEPT,
+    # Short spellings kept for existing shell scripts and sessions.
+    "ask": ApprovalMode.ASK_USER,
+    "full": ApprovalMode.FULL_ACCEPT,
+    "auto": ApprovalMode.FULL_ACCEPT,
+}
+
+
+def shell(
+    prompt: str = typer.Argument(
+        None, help="一次性 prompt；省略进入交互模式"
+    ),
+    workspace: str = typer.Option(
+        ".", "-w", "--workspace", help="workspace 根目录"
+    ),
+    approve_mode: str = typer.Option(
+        ApprovalMode.ASK_USER.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, "-m", "--model", help="覆盖 default_model"
+    ),
+    resume: str = typer.Option(
+        None, "-r", "--resume", help="恢复指定 session_id"
+    ),
+    session: str = typer.Option(
+        None, "-s", "--session", help="指定新 session_id"
+    ),
+    no_stream: bool = typer.Option(
+        False, "--no-stream", help="关闭流式输出"
+    ),
+    subagents: bool = typer.Option(
+        False,
+        "--subagents",
+        help="使用 master/coder 委派模式（await_result）",
+    ),
+    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:
+    """启动交互式 shell（默认子命令）。"""
+    ws = Path(workspace).expanduser().resolve()
+    if not ws.is_dir():
+        console.print(
+            f"[red]workspace 不存在或不是目录:[/red] {ws}"
+        )
+        raise typer.Exit(2)
+
+    selected_approve_mode = _SHELL_APPROVAL_MODES.get(
+        approve_mode.lower()
+    )
+    if selected_approve_mode is None:
+        console.print(
+            "[red]无效 approve mode:[/red] "
+            f"{approve_mode} [dim](ask_user / full_accept)[/dim]"
+        )
+        raise typer.Exit(2)
+
+    try:
+        rc = run_shell(
+            ws,
+            approve_mode=selected_approve_mode,
+            provider_name=provider,
+            model=model,
+            session_id=session,
+            resume=resume,
+            stream=not no_stream,
+            subagents=subagents,
+            one_shot_prompt=prompt,
+            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/status.py

@@ -0,0 +1,37 @@
+"""`mindcode status` 子命令 —— 全局状态。"""
+
+from __future__ import annotations
+
+from rich.table import Table
+
+from ..._version import __logo__, __version__
+from .._shared import console, find_config_file
+
+from ...config import load_config
+
+
+def status() -> None:
+    """显示 mindcode 全局状态。"""
+    console.print(__logo__)
+    console.print(f"mindcode [dim]v{__version__}[/dim]\n")
+
+    config_file = find_config_file()
+    table = Table(show_header=False, box=None, padding=(0, 2))
+    table.add_column(style="bold cyan", width=14)
+    table.add_column()
+    table.add_row("Config:", f"{config_file} [green]✓[/green]")
+
+    config = load_config(config_file)
+    table.add_row("Default:", config.default_provider)
+    table.add_row("Providers:", ", ".join(config.providers))
+
+    for name, p in config.providers.items():
+        key_status = (
+            "[green]✓[/green]" if p.api_key else "[red]✗[/red]"
+        )
+        table.add_row(
+            f"  {name}:",
+            f"{key_status} key  [dim]{p.default_model}[/dim]",
+        )
+
+    console.print(table)

mindcode/cli/commands/task.py

@@ -0,0 +1,417 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import signal
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+import typer
+from mindagent.core import (
+    LocalConversationStore,
+    LocalTaskLedgerStore,
+    LocalTaskMemoryStore,
+    RunOutcome,
+    SessionEnvironment,
+    SessionPolicy,
+    TaskCoordinator,
+)
+from mindagent.tools import MemoryReadTool
+from rich.table import Table
+
+from ...config import load_config
+from ...policy import ApprovalMode
+from ...runtime import build_runtime
+from ...tasking import TaskEventRecorder, TaskStatus, TaskStore
+from .._shared import console
+
+
+app = typer.Typer(help="运行和追踪 mindcode 任务")
+
+
+@app.command("run")
+def run_task(
+    goal: str = typer.Argument(..., help="任务目标"),
+    workspace: str = typer.Option(".", "-w", "--workspace", help="workspace 根目录"),
+    provider: str | None = typer.Option(None, "-p", "--provider", help="覆盖 provider"),
+    model: str | None = typer.Option(None, "--model", help="覆盖 model"),
+    approve_mode: ApprovalMode = typer.Option(
+        ApprovalMode.AUTO.value,
+        "--approve-mode",
+        case_sensitive=False,
+        help="审批模式",
+    ),
+    max_steps: int = typer.Option(50, "--max-steps", help="最大 step 数"),
+    step_timeout: float | None = typer.Option(
+        300.0,
+        "--step-timeout",
+        help="单步超时秒数",
+    ),
+    total_timeout: float | None = typer.Option(
+        1800.0,
+        "--total-timeout",
+        help="总超时秒数",
+    ),
+    allow_dangerous: bool = typer.Option(
+        False,
+        "--allow-dangerous",
+        help="允许 dangerous action",
+    ),
+    background: bool = typer.Option(
+        False,
+        "--background",
+        "-b",
+        help="后台运行 task",
+    ),
+) -> None:
+    ws = Path(workspace).expanduser().resolve()
+    if not ws.is_dir():
+        console.print(f"[red]workspace 不存在或不是目录:[/red] {ws}")
+        raise typer.Exit(2)
+
+    config = load_config()
+    provider_config = config.get_provider(provider)
+    model_name = provider_config.resolve_model(model)
+    store = TaskStore()
+    record = store.create(
+        goal=goal,
+        workspace=ws,
+        provider=provider_config.name,
+        model=model_name,
+        approve_mode=ApprovalMode(approve_mode).value,
+        background=background,
+        max_steps=max_steps,
+        total_timeout_s=total_timeout,
+        allow_dangerous=allow_dangerous,
+    )
+    console.print(f"task_id={record.task_id}")
+
+    if background:
+        _start_background_worker(store, record.task_id)
+        return
+
+    try:
+        ok = asyncio.run(
+            _run_task(
+                store=store,
+                task_id=record.task_id,
+                goal=goal,
+                workspace=ws,
+                provider_name=provider_config.name,
+                model=model_name,
+                approve_mode=ApprovalMode(approve_mode),
+                max_steps=max_steps,
+                step_timeout=step_timeout,
+                total_timeout=total_timeout,
+                allow_dangerous=allow_dangerous,
+            )
+        )
+        if not ok:
+            raise typer.Exit(1)
+    except ValueError as exc:
+        console.print(f"[red]配置错误:[/red] {exc}")
+        raise typer.Exit(2)
+
+
+def _start_background_worker(store: TaskStore, task_id: str) -> None:
+    task_dir = store.task_dir(task_id)
+    task_dir.mkdir(parents=True, exist_ok=True)
+    (task_dir / "events.jsonl").touch(exist_ok=True)
+    log_path = task_dir / "worker.log"
+    cmd = [sys.executable, "-m", "mindcode", "task", "_worker", task_id]
+    with log_path.open("ab") as log:
+        process = subprocess.Popen(
+            cmd,
+            stdout=log,
+            stderr=subprocess.STDOUT,
+            cwd=Path.cwd(),
+            env=os.environ.copy(),
+        )
+    record = store.load(task_id)
+    record.pid = process.pid
+    store.save(record)
+    console.print(f"background pid={process.pid}")
+    console.print(f"events={task_dir / 'events.jsonl'}")
+
+
+@app.command("_worker", hidden=True)
+def task_worker(task_id: str) -> None:
+    store = TaskStore()
+    record = store.load(task_id)
+    ok = asyncio.run(
+        _run_task(
+            store=store,
+            task_id=record.task_id,
+            goal=record.goal,
+            workspace=Path(record.workspace),
+            provider_name=record.provider,
+            model=record.model or "",
+            approve_mode=ApprovalMode(record.approve_mode),
+            max_steps=record.max_steps,
+            step_timeout=getattr(record, "step_timeout_s", 300.0),
+            total_timeout=record.total_timeout_s,
+            allow_dangerous=record.allow_dangerous,
+        )
+    )
+    if not ok:
+        raise typer.Exit(1)
+
+
+@app.command("resume")
+def resume_task(
+    task_id: str = typer.Argument(..., help="要恢复的 task_id"),
+    message: str | None = typer.Option(
+        None,
+        "--message",
+        "-m",
+        help="恢复时追加给主 Agent 的消息",
+    ),
+) -> None:
+    store = TaskStore()
+    try:
+        record = store.load(task_id)
+    except FileNotFoundError:
+        console.print(f"[red]task 不存在:[/red] {task_id}")
+        raise typer.Exit(2)
+    try:
+        ok = asyncio.run(
+            _run_task(
+                store=store,
+                task_id=record.task_id,
+                goal=record.goal,
+                workspace=Path(record.workspace),
+                provider_name=record.provider,
+                model=record.model or "",
+                approve_mode=ApprovalMode(record.approve_mode),
+                max_steps=record.max_steps,
+                step_timeout=getattr(record, "step_timeout_s", 300.0),
+                total_timeout=record.total_timeout_s,
+                allow_dangerous=record.allow_dangerous,
+                resume=True,
+                user_input=message,
+            )
+        )
+        if not ok:
+            raise typer.Exit(1)
+    except ValueError as exc:
+        console.print(f"[red]无法恢复:[/red] {exc}")
+        raise typer.Exit(2)
+
+
+async def _run_task(
+    *,
+    store: TaskStore,
+    task_id: str,
+    goal: str,
+    workspace: Path,
+    provider_name: str,
+    model: str,
+    approve_mode: ApprovalMode,
+    max_steps: int,
+    total_timeout: float | None,
+    allow_dangerous: bool,
+    step_timeout: float | None = 300.0,
+    resume: bool = False,
+    user_input: str | None = None,
+) -> bool:
+    record = store.load(task_id)
+    record.status = TaskStatus.RUNNING.value
+    record.started_at = time.time()
+    record.completed_at = None
+    record.error = None
+    record.pid = os.getpid()
+    store.save(record)
+
+    recorder = TaskEventRecorder(store, task_id)
+    memory_store = LocalTaskMemoryStore(store.task_dir(task_id))
+    runtime = None
+    try:
+        config = load_config()
+        provider_config = config.get_provider(provider_name)
+        runtime = build_runtime(
+            workspace,
+            provider_config=provider_config,
+            approve_mode=approve_mode,
+            model=model,
+            stream=False,
+            event_handler=recorder,
+            max_steps=max_steps,
+            step_timeout_s=step_timeout,
+            total_timeout_s=total_timeout,
+            extra_tools=[MemoryReadTool(memory_store)],
+        )
+
+        environment = SessionEnvironment(
+            workspace_root=workspace,
+            working_directory=workspace,
+            metadata={"mindcode_task_id": task_id},
+        )
+        policy = SessionPolicy(
+            allowed_tools=frozenset(
+                {
+                    "file_read",
+                    "file_write",
+                    "file_edit",
+                    "exec_command",
+                    "memory_read",
+                }
+            ),
+            allow_write=True,
+            allow_dangerous=allow_dangerous,
+            max_parallel_actions=1,
+        )
+        session = runtime.create_session(
+            session_id=task_id,
+            environment=environment,
+            policy=policy,
+            conversation_store=LocalConversationStore(
+                store.task_dir(task_id) / "conversation"
+            ),
+        )
+        coordinator = TaskCoordinator(
+            session,
+            LocalTaskLedgerStore(store.root),
+            memory_store,
+            task_id=task_id,
+        )
+        if resume:
+            result = await coordinator.resume(user_input=user_input)
+        else:
+            result = await coordinator.run(goal)
+    except Exception as exc:
+        record = store.load(task_id)
+        record.completed_at = time.time()
+        record.status = TaskStatus.FAILED.value
+        record.pid = None
+        record.error = f"{type(exc).__name__}: {exc}"
+        record.metrics = {
+            "tool_calls": recorder.tool_calls,
+            "agent_events": recorder.agent_events,
+        }
+        store.save(record)
+        store.write_summary(record)
+        console.print(f"[red]failed[/red] {record.error}")
+        return False
+    finally:
+        if runtime is not None:
+            await runtime.close(close_dependencies=True)
+
+    record = store.load(task_id)
+    record.completed_at = time.time()
+    record.pid = None
+    record.run_id = result.run_id
+    record.final_answer = result.final_answer
+    record.error = result.error
+    record.status = {
+        RunOutcome.FINAL: TaskStatus.COMPLETED.value,
+        RunOutcome.PARTIAL: TaskStatus.PARTIAL.value,
+        RunOutcome.ERROR: TaskStatus.FAILED.value,
+        RunOutcome.CANCELLED: TaskStatus.CANCELLED.value,
+    }[result.outcome]
+    record.metrics = {
+        "steps": result.steps,
+        "tool_calls": recorder.tool_calls,
+        "agent_events": recorder.agent_events,
+        "run_outcome": result.outcome.value,
+    }
+    store.save(record)
+    store.write_summary(record)
+    if record.error:
+        console.print(f"[red]failed[/red] {record.error}")
+        return False
+    console.print(f"[green]completed[/green] {task_id}")
+    if record.final_answer:
+        console.print(record.final_answer)
+    return True
+
+
+@app.command("list")
+def list_tasks() -> None:
+    store = TaskStore()
+    table = Table("task_id", "status", "workspace", "goal")
+    for record in store.list():
+        table.add_row(
+            record.task_id,
+            record.status,
+            record.workspace,
+            _shorten(record.goal, 60),
+        )
+    console.print(table)
+
+
+@app.command("status")
+def task_status(task_id: str) -> None:
+    store = TaskStore()
+    try:
+        record = store.refresh(store.load(task_id))
+    except FileNotFoundError:
+        console.print(f"[red]task 不存在:[/red] {task_id}")
+        raise typer.Exit(2)
+    console.print(json.dumps(record.__dict__, ensure_ascii=False, indent=2))
+
+
+@app.command("tail")
+def task_tail(
+    task_id: str,
+    lines: int = typer.Option(30, "--lines", "-n", help="显示最近事件行数"),
+    follow: bool = typer.Option(False, "--follow", "-f", help="持续追踪事件"),
+) -> None:
+    store = TaskStore()
+    path = store.task_dir(task_id) / "events.jsonl"
+    if not path.exists():
+        console.print(f"[red]events 不存在:[/red] {task_id}")
+        raise typer.Exit(2)
+    rows = path.read_text(encoding="utf-8").splitlines()[-lines:]
+    for row in rows:
+        _print_event_row(row)
+    if not follow:
+        return
+    offset = path.stat().st_size
+    while True:
+        time.sleep(1)
+        with path.open(encoding="utf-8") as file:
+            file.seek(offset)
+            for row in file:
+                _print_event_row(row)
+            offset = file.tell()
+
+
+@app.command("cancel")
+def task_cancel(task_id: str) -> None:
+    store = TaskStore()
+    try:
+        record = store.load(task_id)
+    except FileNotFoundError:
+        console.print(f"[red]task 不存在:[/red] {task_id}")
+        raise typer.Exit(2)
+    cancellable = {TaskStatus.CREATED.value, TaskStatus.RUNNING.value}
+    if record.pid is None or record.status not in cancellable:
+        console.print(f"[yellow]task 当前不可取消:[/yellow] {record.status}")
+        raise typer.Exit(1)
+    try:
+        os.kill(record.pid, signal.SIGTERM)
+    except ProcessLookupError:
+        pass
+    record.status = TaskStatus.CANCELLED.value
+    record.completed_at = time.time()
+    record.error = "cancelled by user"
+    store.save(record)
+    store.write_summary(record)
+    console.print(f"cancelled {task_id}")
+
+
+def _print_event_row(row: str) -> None:
+    item = json.loads(row)
+    console.print(
+        f"{item['event_type']} {item['state']} "
+        f"{_shorten(str(item.get('payload', {})), 120)}"
+    )
+
+
+def _shorten(text: str, limit: int) -> str:
+    if len(text) <= limit:
+        return text
+    return text[: limit - 3] + "..."