multi-agent-platform 0.1.0__py3-none-any.whl

cli/runtime_chat.py

@@ -0,0 +1,317 @@
+"""Interactive MAP runtime chat — resume a persona session from the terminal.
+
+Unlike map-runtime-waker (one prompt per wake), ``map runtime chat`` keeps the
+Claude SDK connection open and accepts multiple user turns. Manual mode does not
+call the D6 ``inbound-event record`` server gate.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import subprocess
+import sys
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+import typer
+from map_client.project_config import find_map_dir
+
+from cli.agent_client import PersonaAgentClient, WakeUpEvent
+from cli.bridge_state import load_bridge_state, save_bridge_state
+from cli.host_worker_types import WorkerError
+from cli.wake_backend import sync_runtime_skills
+
+DEFAULT_STATE_TEMPLATE = ".map/runtime-waker-state-{persona}.json"
+DEFAULT_RUNTIME_HOME_TEMPLATE = ".map/claude-runtime-home-{persona}"
+
+_REPL_HELP = """\
+Commands:
+  /help, /?     Show this help
+  /session      Print resumed Claude session id
+  /quit, /exit  End chat (Ctrl+D also quits)
+"""
+
+
+def resolve_project_root(project_root: Path | None) -> Path:
+    if project_root is not None:
+        return project_root.resolve()
+    map_dir = find_map_dir(None)
+    return map_dir.parent.resolve()
+
+
+def default_state_file(project_root: Path, persona: str) -> Path:
+    return project_root / DEFAULT_STATE_TEMPLATE.format(persona=persona)
+
+
+def default_runtime_home(project_root: Path, persona: str) -> Path:
+    return project_root / DEFAULT_RUNTIME_HOME_TEMPLATE.format(persona=persona)
+
+
+def load_runtime_state(state_file: Path) -> dict[str, Any]:
+    return load_bridge_state(
+        state_file,
+        bridge_name="runtime-waker",
+        default_collections=("personas",),
+    )
+
+
+def persona_agent_state(state: dict[str, Any], persona: str) -> dict[str, Any]:
+    personas = state.setdefault("personas", {})
+    if not isinstance(personas, dict):
+        personas = {}
+        state["personas"] = personas
+    persona_state = personas.setdefault(persona, {})
+    if not isinstance(persona_state, dict):
+        persona_state = {}
+        personas[persona] = persona_state
+    return persona_state
+
+
+def resolve_session_id(
+    persona_state: dict[str, Any],
+    *,
+    session_id: str | None,
+    new_session: bool,
+) -> str | None:
+    if new_session:
+        return None
+    if session_id:
+        return session_id
+    for key in ("claude_session_id", "runtime_session_id"):
+        value = persona_state.get(key)
+        if value:
+            return str(value)
+    return None
+
+
+def find_runtime_waker_pids(persona: str) -> list[int]:
+    # simple-waker 是默认 waker，实际进程是
+    # `python3 -m cli.simple_waker --persona <persona>`（legacy runtime-waker
+    # SSE 路径已下线）。
+    pattern = rf"cli\.simple_waker.*--persona {persona}"
+    result = subprocess.run(
+        ["pgrep", "-f", pattern],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode != 0:
+        return []
+    pids: list[int] = []
+    for line in result.stdout.splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            pids.append(int(line))
+        except ValueError:
+            continue
+    return pids
+
+
+def ensure_waker_not_running(*, persona: str, ignore_waker: bool) -> None:
+    if ignore_waker:
+        return
+    pids = find_runtime_waker_pids(persona)
+    if not pids:
+        return
+    pid_list = ", ".join(str(pid) for pid in pids)
+    raise WorkerError(
+        f"runtime waker for persona={persona!r} is already running (pid(s): {pid_list}). "
+        "Stop it before `map runtime chat` to avoid session conflicts, or pass --ignore-waker."
+    )
+
+
+def format_session_banner(
+    *,
+    persona: str,
+    session_id: str | None,
+    state_file: Path,
+    runtime_home: Path,
+    resumed: bool,
+) -> str:
+    session_label = session_id or "<new session>"
+    mode = "resume" if resumed else "new"
+    return (
+        f"MAP runtime chat · persona={persona} · {mode} · session={session_label}\n"
+        f"state={state_file}\n"
+        f"runtime_home={runtime_home}\n"
+        "Type /help for commands. Empty line is ignored.\n"
+    )
+
+
+def _default_on_event(event: WakeUpEvent) -> None:
+    if event.get("type") == "text":
+        sys.stdout.write(str(event.get("content") or ""))
+        sys.stdout.flush()
+
+
+async def run_chat_loop(
+    client: PersonaAgentClient,
+    *,
+    initial_prompt: str | None,
+    input_fn: Callable[[str], str] = input,
+    on_event: Callable[[WakeUpEvent], None] | None = None,
+) -> None:
+    emit = on_event or _default_on_event
+
+    async def turn(prompt: str) -> str:
+        return await client.wake_up(
+            prompt,
+            on_event=emit,
+            event_source="manual",
+        )
+
+    await client.connect()
+
+    if initial_prompt:
+        typer.echo(f"\n[prompt] {initial_prompt}\n")
+        status = await turn(initial_prompt)
+        if status == "error":
+            raise WorkerError("Claude returned error status for initial prompt")
+        typer.echo("\n")
+
+    while True:
+        try:
+            line = input_fn("map> ").strip()
+        except EOFError:
+            typer.echo("")
+            break
+        if not line:
+            continue
+        lowered = line.lower()
+        if lowered in {"/quit", "/exit", "/q"}:
+            break
+        if lowered in {"/help", "/?"}:
+            typer.echo(_REPL_HELP)
+            continue
+        if lowered == "/session":
+            sid = client.state.get("claude_session_id") or client.state.get("runtime_session_id")
+            typer.echo(sid or "<none>")
+            continue
+
+        typer.echo("")
+        status = await turn(line)
+        if status == "error":
+            typer.echo("\n[error] Claude returned error status for this turn.", err=True)
+        typer.echo("\n")
+
+    await client.disconnect()
+
+
+async def run_runtime_chat_async(
+    *,
+    persona: str,
+    project_root: Path | None,
+    state_file: Path | None,
+    runtime_home: Path | None,
+    session_id: str | None,
+    new_session: bool,
+    initial_prompt: str | None,
+    ignore_waker: bool,
+    model: str | None,
+) -> None:
+    root = resolve_project_root(project_root)
+    resolved_state_file = (state_file or default_state_file(root, persona)).resolve()
+    resolved_runtime_home = (runtime_home or default_runtime_home(root, persona)).resolve()
+
+    ensure_waker_not_running(persona=persona, ignore_waker=ignore_waker)
+
+    state = load_runtime_state(resolved_state_file)
+    agent_state = persona_agent_state(state, persona)
+    resume_id = resolve_session_id(agent_state, session_id=session_id, new_session=new_session)
+    if new_session:
+        agent_state.pop("claude_session_id", None)
+        agent_state.pop("runtime_session_id", None)
+
+    sync_runtime_skills(project_root=root, runtime_home=resolved_runtime_home)
+    resolved_runtime_home.mkdir(parents=True, exist_ok=True)
+
+    def save_state() -> None:
+        save_bridge_state(resolved_state_file, state)
+
+    extra_env = {
+        "HOME": str(resolved_runtime_home),
+        "MAP_RUNTIME_CHAT_PERSONA": persona,
+    }
+
+    client = PersonaAgentClient(
+        persona=persona,
+        state=agent_state,
+        save_state_fn=save_state,
+        project_root=root,
+        extra_env=extra_env,
+        model=model,
+        integration="manual",
+    )
+
+    if resume_id and not new_session:
+        client.state["claude_session_id"] = resume_id
+        client.state["runtime_session_id"] = resume_id
+
+    typer.echo(
+        format_session_banner(
+            persona=persona,
+            session_id=resume_id,
+            state_file=resolved_state_file,
+            runtime_home=resolved_runtime_home,
+            resumed=bool(resume_id),
+        )
+    )
+
+    try:
+        await run_chat_loop(client, initial_prompt=initial_prompt)
+    finally:
+        save_state()
+
+
+def run_runtime_chat(**kwargs: Any) -> None:
+    try:
+        asyncio.run(run_runtime_chat_async(**kwargs))
+    except WorkerError as exc:
+        typer.echo(f"Error: {exc}", err=True)
+        raise typer.Exit(1) from exc
+    except KeyboardInterrupt:
+        typer.echo("\nInterrupted.")
+        raise typer.Exit(130) from None
+
+
+def dump_runtime_chat_status(
+    *,
+    persona: str,
+    project_root: Path | None,
+    state_file: Path | None,
+) -> dict[str, Any]:
+    root = resolve_project_root(project_root)
+    resolved_state_file = (state_file or default_state_file(root, persona)).resolve()
+    state = load_runtime_state(resolved_state_file)
+    agent_state = persona_agent_state(state, persona)
+    session_id = resolve_session_id(agent_state, session_id=None, new_session=False)
+    return {
+        "persona": persona,
+        "project_root": str(root),
+        "state_file": str(resolved_state_file),
+        "runtime_home": str(default_runtime_home(root, persona)),
+        "session_id": session_id,
+        "waker_pids": find_runtime_waker_pids(persona),
+        "last_wakeup_at": agent_state.get("last_wakeup_at"),
+        "last_wakeup_status": agent_state.get("last_wakeup_status"),
+    }
+
+
+__all__ = [
+    "default_runtime_home",
+    "default_state_file",
+    "dump_runtime_chat_status",
+    "ensure_waker_not_running",
+    "find_runtime_waker_pids",
+    "format_session_banner",
+    "load_runtime_state",
+    "persona_agent_state",
+    "resolve_project_root",
+    "resolve_session_id",
+    "run_chat_loop",
+    "run_runtime_chat",
+    "run_runtime_chat_async",
+]

cli/session_wake_log.py

@@ -0,0 +1,235 @@
+"""Append-only per-session wake logs for PersonaAgentClient."""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+from zoneinfo import ZoneInfo
+
+DEFAULT_SESSION_LOG_DIR = Path(".map/runtime-waker-sessions")
+DEFAULT_LOG_TIMEZONE = "Asia/Shanghai"
+RESPONSE_PREVIEW_MAX = 200
+
+_SAFE_SESSION_ID_RE = re.compile(r"[^\w.\-]+")
+
+
+def log_timezone() -> ZoneInfo:
+    """Timezone for human-readable session log timestamps (default: Asia/Shanghai)."""
+    return ZoneInfo(os.environ.get("MAP_LOG_TIMEZONE", DEFAULT_LOG_TIMEZONE))
+
+
+def log_now() -> datetime:
+    return datetime.now(log_timezone())
+
+
+def safe_session_log_name(session_id: str) -> str:
+    """Turn a session id into a single path segment safe for log filenames."""
+    safe = _SAFE_SESSION_ID_RE.sub("_", session_id.strip())
+    return safe or "unknown"
+
+
+def resolve_session_log_path(log_dir: Path, session_id: str, persona: str) -> Path:
+    """Resolve the JSONL path for a session (reuse existing file across resume wakes)."""
+    safe_id = safe_session_log_name(session_id)
+    safe_persona = safe_session_log_name(persona)
+    # Persona must be part of the lookup — multiple wakers can share the same
+    # provisional ``new-YYYYMMDDTHHMMSS`` id when they wake in the same second.
+    stamped = sorted(
+        log_dir.glob(f"*_{safe_persona}_{safe_id}.jsonl"),
+        key=lambda path: path.stat().st_mtime,
+    )
+    if stamped:
+        return stamped[-1]
+    legacy = log_dir / f"{safe_id}.jsonl"
+    if legacy.exists():
+        return legacy
+    ts = log_now().strftime("%Y%m%d-%H%M%S")
+    return log_dir / f"{ts}_{safe_persona}_{safe_id}.jsonl"
+
+
+def response_preview(text: str, *, max_chars: int = RESPONSE_PREVIEW_MAX) -> str:
+    if max_chars <= 0:
+        return ""
+    return text[:max_chars]
+
+
+EVENT_SUMMARY_MAX = 160
+
+# Scalar input fields that best describe what a tool call is doing, in priority
+# order — keeps tool_use summaries short and human-scannable (which command,
+# which file) instead of dumping the whole input dict.
+_TOOL_INPUT_PRIORITY: tuple[str, ...] = (
+    "command",
+    "description",
+    "file_path",
+    "path",
+    "pattern",
+    "url",
+    "query",
+    "body",
+)
+
+
+def _scalar_preview(value: Any, *, max_chars: int) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, str):
+        return value[:max_chars]
+    return json.dumps(value, ensure_ascii=False)[:max_chars]
+
+
+def text_summary(text: str | None, *, max_chars: int = EVENT_SUMMARY_MAX) -> str:
+    """One-line preview of assistant text (newlines collapsed)."""
+    if not text:
+        return ""
+    return " ".join(text.split())[:max_chars]
+
+
+def tool_use_summary(
+    name: str,
+    tool_input: Any,
+    *,
+    max_chars: int = EVENT_SUMMARY_MAX,
+) -> str:
+    """Short summary of a tool call, e.g. ``Bash: pytest tests/ -q``."""
+    if isinstance(tool_input, dict):
+        for key in _TOOL_INPUT_PRIORITY:
+            if tool_input.get(key) is not None:
+                return f"{name}: {_scalar_preview(tool_input[key], max_chars=max_chars)}"
+        for value in tool_input.values():
+            if isinstance(value, (str, int, float, bool)):
+                return f"{name}: {_scalar_preview(value, max_chars=max_chars)}"
+        return str(name)
+    return f"{name}: {_scalar_preview(tool_input, max_chars=max_chars)}"
+
+
+def tool_result_summary(
+    content: Any,
+    is_error: bool | None,
+    *,
+    max_chars: int = EVENT_SUMMARY_MAX,
+) -> str:
+    """Short summary of a tool result, e.g. ``ok: 45 passed`` or ``error: ...``."""
+    label = "error" if is_error else "ok"
+    if content is None:
+        return label
+    if isinstance(content, str):
+        body = content
+    elif isinstance(content, list):
+        parts: list[str] = []
+        for item in content:
+            if isinstance(item, dict):
+                parts.append(str(item.get("text") or item.get("content") or ""))
+            else:
+                parts.append(str(item))
+        body = " ".join(p for p in parts if p)
+    else:
+        body = str(content)
+    body = " ".join(body.split())
+    if not body:
+        return label
+    return f"{label}: {body[:max_chars]}"
+
+
+def append_session_wake_log(
+    *,
+    log_dir: Path,
+    session_id: str,
+    persona: str,
+    integration: str,
+    prompt: str,
+    response_text: str,
+    status: str,
+    preview_chars: int = RESPONSE_PREVIEW_MAX,
+    event_id: str | None = None,
+    event_source: str = "polling",
+    fingerprint: str | None = None,
+    log_path: Path | None = None,
+) -> Path:
+    """Append one JSON line to the session's JSONL file under ``log_dir``.
+
+    ``event_id`` and ``event_source`` are the join keys for the A3 audit
+    three-way join (notification ↔ inbound_event ↔ sessions jsonl). Default
+    ``event_source="polling"`` matches Phase 1 reality; Phase 2 will start
+    emitting ``sse`` once the event-driven path is wired.
+    ``fingerprint`` is optional — included when the caller has it on hand so
+    A3 join fallbacks can pivot on it without consulting inbound_event.
+    """
+    log_dir.mkdir(parents=True, exist_ok=True)
+    # When the caller already resolved a log_path (e.g. wake_up writes live
+    # events into one file and wants the result summary in that same file),
+    # honor it instead of re-resolving by session_id.
+    path = log_path if log_path is not None else resolve_session_log_path(log_dir, session_id, persona)
+    entry: dict[str, Any] = {
+        "ts": log_now().isoformat(),
+        "session_id": session_id,
+        "persona": persona,
+        "integration": integration,
+        "status": status,
+        "event_source": event_source,
+        "event_id": event_id,
+        "fingerprint": fingerprint,
+        "prompt": prompt,
+        "response_preview": response_preview(response_text, max_chars=preview_chars),
+        "response_chars": len(response_text),
+    }
+    with path.open("a", encoding="utf-8") as handle:
+        handle.write(json.dumps(entry, ensure_ascii=False) + "\n")
+    return path
+
+
+def append_session_event(
+    *,
+    log_path: Path,
+    persona: str,
+    integration: str,
+    event: str,
+    summary: str,
+    event_id: str | None = None,
+    event_source: str = "polling",
+    fingerprint: str | None = None,
+) -> None:
+    """Append one real-time event line to a session's JSONL file.
+
+    Called live during ``PersonaAgentClient.wake_up()`` for each assistant text
+    block, tool call, and tool result, so an agent stuck mid-turn is visible
+    from the timestamp of the last written event. ``event`` is one of
+    ``wake``/``text``/``tool_use``/``tool_result``/``result``. The caller
+    resolves ``log_path`` once up front (via :func:`resolve_session_log_path`)
+    so every event of one wake lands in the same file.
+    """
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+    entry: dict[str, Any] = {
+        "ts": log_now().isoformat(),
+        "persona": persona,
+        "integration": integration,
+        "event": event,
+        "summary": summary,
+        "event_source": event_source,
+        "event_id": event_id,
+        "fingerprint": fingerprint,
+    }
+    with log_path.open("a", encoding="utf-8") as handle:
+        handle.write(json.dumps(entry, ensure_ascii=False) + "\n")
+
+
+__all__ = [
+    "DEFAULT_LOG_TIMEZONE",
+    "DEFAULT_SESSION_LOG_DIR",
+    "EVENT_SUMMARY_MAX",
+    "RESPONSE_PREVIEW_MAX",
+    "append_session_event",
+    "append_session_wake_log",
+    "log_now",
+    "log_timezone",
+    "resolve_session_log_path",
+    "response_preview",
+    "safe_session_log_name",
+    "text_summary",
+    "tool_result_summary",
+    "tool_use_summary",
+]