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

cli/commands/feedback.py

@@ -0,0 +1,106 @@
+"""``map feedback ...`` sub-app — arch experiment 0519e2a3 PR7.
+
+Platform feedback inbox. ``submit`` is persona-scoped; ``list`` / ``get`` /
+``update`` are admin-only (used for triage).
+
+All command bodies lazy-import ``cli.main._run`` to break the
+``cli.main ↔ cli.commands.*`` import cycle.
+"""
+from __future__ import annotations
+
+import uuid
+from pathlib import Path
+
+import typer
+from map_client.client import MAPClient
+
+feedback_app = typer.Typer(help="Platform feedback inbox commands")
+
+
+@feedback_app.command("submit")
+def feedback_submit(
+    body: str | None = typer.Option(None, "--body", help="Feedback text (free-form)."),
+    body_file: Path | None = typer.Option(
+        None,
+        "--file",
+        help="Read feedback body from a file (avoids shell-quoting issues with backticks / $vars).",
+    ),
+    category: str | None = typer.Option(
+        None, "--category", help="bug|suggestion|question|other (optional, admin triage hint)"
+    ),
+    project: uuid.UUID | None = typer.Option(
+        None, "--project", help="Source project context (optional)"
+    ),
+) -> None:
+    from map_types.enums import FeedbackCategory
+
+    from cli.main import _read_text_file, _run  # lazy: avoid cli.main ↔ cli.commands.* cycle
+    from server.domain.schemas import PlatformFeedbackCreate
+
+    if body is None and body_file is None:
+        typer.echo("Error: either --body or --file is required", err=True)
+        raise typer.Exit(2)
+    if body is not None and body_file is not None:
+        typer.echo("Error: use only one of --body or --file", err=True)
+        raise typer.Exit(2)
+    content = body if body is not None else _read_text_file(body_file, kind="feedback")
+    payload = PlatformFeedbackCreate(
+        body=content,
+        project_id=project,
+        category=FeedbackCategory(category) if category else None,
+    )
+    _run(lambda c: c.submit_feedback(payload))
+
+
+@feedback_app.command("list")
+def feedback_list(
+    status: str | None = typer.Option(None, "--status"),
+    category: str | None = typer.Option(None, "--category"),
+    project: uuid.UUID | None = typer.Option(None, "--project"),
+    page: int = typer.Option(1, "--page", min=1),
+    page_size: int = typer.Option(50, "--page-size", min=1, max=200),
+    include_archived: bool = typer.Option(False, "--include-archived"),
+) -> None:
+    from map_types.enums import FeedbackCategory, FeedbackStatus
+
+    from cli.main import _run  # lazy
+
+    def action(c: MAPClient):
+        items, total = c.list_feedback_page(
+            status=FeedbackStatus(status) if status else None,
+            category=FeedbackCategory(category) if category else None,
+            project_id=project,
+            page=page,
+            page_size=page_size,
+            include_archived=include_archived,
+        )
+        return {"items": items, "total": total}
+
+    _run(action, admin=True)
+
+
+@feedback_app.command("get")
+def feedback_get(feedback_id: uuid.UUID = typer.Argument(..., help="Feedback UUID")) -> None:
+    from cli.main import _run  # lazy
+
+    _run(lambda c: c.get_feedback(feedback_id), admin=True)
+
+
+@feedback_app.command("update")
+def feedback_update(
+    feedback_id: uuid.UUID = typer.Argument(..., help="Feedback UUID"),
+    status: str | None = typer.Option(None, "--status"),
+    category: str | None = typer.Option(None, "--category"),
+    archived: bool | None = typer.Option(None, "--archived/--no-archived"),
+) -> None:
+    from map_types.enums import FeedbackCategory, FeedbackStatus
+
+    from cli.main import _run  # lazy
+    from server.domain.schemas import PlatformFeedbackUpdate
+
+    payload = PlatformFeedbackUpdate(
+        status=FeedbackStatus(status) if status else None,
+        category=FeedbackCategory(category) if category else None,
+        archived=archived,
+    )
+    _run(lambda c: c.update_feedback(feedback_id, payload), admin=True)

cli/commands/notification.py

@@ -0,0 +1,213 @@
+"""``map notification ...`` + ``map inbound-event ...`` sub-apps — arch PR5.
+
+Wraps the personal-inbox / waker-event surface:
+
+* ``map notification list`` —
+  ``GET /api/v1/notifications`` with category/target_type/unread_only filters.
+* ``map notification read`` —
+  ``POST /notifications/{id}/read`` (one notification at a time).
+* ``map notification read-all`` (cli-ux PR2: + ``--category`` + ``--event``) —
+  ``POST /notifications/read-all`` for the unfiltered fast path, OR enumerate
+  via ``list`` + ``mark_notification_read`` for filtered bulk. Mirrors the
+  wakeable / digest view surfaced in the web todo UI.
+* ``map inbound-event record`` —
+  ``POST /api/v1/agents/me/inbound-events``. Waker-side D6 gate;
+  on 409 the CLI exits non-zero so the waker treats it as
+  "already woken" and skips resume.
+"""
+from __future__ import annotations
+
+import json
+import uuid
+from pathlib import Path
+from typing import Any
+
+import typer
+from map_client.client import MAPClient
+from map_client.exceptions import MAPConflictError
+
+from cli.table_render import enum_value, format_datetime, render_table, short_uuid, truncate
+
+notification_app = typer.Typer(help="Notification commands (personal inbox)")
+
+
+def _render_notification_table(result: Any) -> str:
+    """Render a NotificationListRead as a compact table with summary footer."""
+    items = result.items if hasattr(result, "items") else result
+    total = getattr(result, "total", len(items))
+    unread = getattr(result, "unread_count", 0)
+
+    headers = ["ID", "Event", "Summary", "Category", "Read", "Created"]
+    rows = []
+    for n in items:
+        rows.append([
+            short_uuid(n.id),
+            truncate(n.event, 30),
+            truncate(n.summary, 50),
+            enum_value(n.category),
+            "yes" if n.read_at else "no",
+            format_datetime(n.created_at),
+        ])
+    table = render_table(headers, rows)
+    footer = f"\n({len(items)} shown, {unread} unread / {total} total)"
+    return table + footer
+
+
+@notification_app.command("list")
+def notification_list(
+    unread_only: bool = typer.Option(False, "--unread-only", help="Only show unread."),
+    category: str | None = typer.Option(
+        None, "--category", help="wakeable | digest | all (filter by category)."
+    ),
+    target_type: str | None = typer.Option(
+        None, "--target-type", help="Filter by notification.target_type."
+    ),
+    limit: int = typer.Option(50, "--limit", min=1, max=200),
+    offset: int = typer.Option(0, "--offset", min=0),
+) -> None:
+    """List the current persona's notifications.
+
+    Defaults to a compact table view. Use ``--format yaml`` or
+    ``--format json`` for full structured output (scripts / piping).
+    """
+    from cli.main import _run  # lazy: avoid cli.main ↔ cli.commands.* cycle
+
+    def action(c: Any) -> Any:
+        return c.list_notifications(
+            unread_only=unread_only,
+            category=category,
+            target_type=target_type,
+            limit=limit,
+            offset=offset,
+        )
+
+    _run(action, table_renderer=_render_notification_table)
+
+
+@notification_app.command("read")
+def notification_read(
+    notification_id: uuid.UUID = typer.Option(..., "--id", help="Notification UUID."),
+) -> None:
+    """Mark one notification as read."""
+    from cli.main import _run
+
+    def action(c: Any) -> Any:
+        return c.mark_notification_read(notification_id)
+
+    _run(action)
+
+
+@notification_app.command("read-all")
+def notification_read_all(
+    category: str | None = typer.Option(
+        None,
+        "--category",
+        help="Filter by category before bulk-marking: wakeable | digest | all (default = all).",
+    ),
+    event: str | None = typer.Option(
+        None,
+        "--event",
+        help="Filter by notification.event before bulk-marking "
+        "(client-side filter; e.g. mention.created, experiment.phase_changed).",
+    ),
+) -> None:
+    """Mark every (filtered) notification for the current persona as read.
+
+    Without filters this hits the bulk ``POST /agents/me/notifications/read-all``
+    endpoint in a single round-trip. With ``--category`` or ``--event`` set, the
+    CLI enumerates the matching subset via ``list_notifications`` then marks each
+    via ``mark_notification_read`` (still fewer round-trips than ``read --id``
+    one-at-a-time, and doesn't require knowing IDs upfront).
+    """
+    from map_types.enums import NotificationCategory
+
+    from cli.main import _run
+
+    # Validate --category early so user sees a clean error before any API call.
+    if category is not None and category not in ("wakeable", "digest", "all"):
+        typer.echo(
+            f"Error: --category must be one of wakeable|digest|all (got {category!r})",
+            err=True,
+        )
+        raise typer.Exit(2)
+
+    def action(c: Any) -> Any:
+        if category is None and event is None:
+            # Fast path: single bulk endpoint, no enumeration.
+            return c.mark_all_notifications_read()
+
+        # Filtered path: enumerate, then mark each match.
+        list_kwargs: dict = {"unread_only": True, "limit": 200}
+        if category is not None and category != "all":
+            list_kwargs["category"] = NotificationCategory(category)
+        # Pagination loop — most personas have < 200 unread, but loop if more.
+        marked = 0
+        offset = 0
+        while True:
+            list_kwargs["offset"] = offset
+            page = c.list_notifications(**list_kwargs)
+            if not page.items:
+                break
+            for n in page.items:
+                if event is not None and getattr(n, "event", None) != event:
+                    continue
+                c.mark_notification_read(n.id)
+                marked += 1
+            offset += len(page.items)
+            if offset >= page.total:
+                break
+        return {"marked": marked}
+
+    _run(action)
+
+
+inbound_event_app = typer.Typer(
+    help="Runtime-waker inbound event commands (D6 server gate)"
+)
+
+
+@inbound_event_app.command("record")
+def inbound_event_record(
+    event_id: uuid.UUID = typer.Option(
+        ..., "--event-id", help="Upstream notification id (UUID)."
+    ),
+    fingerprint: str = typer.Option(
+        ..., "--fingerprint", help="Dedup key (server enforces UNIQUE per agent)."
+    ),
+    event_type: str = typer.Option(
+        ...,
+        "--event-type",
+        help="Logical event type (e.g. mention, pending_review, topic_lifecycle).",
+    ),
+    source: str = typer.Option(
+        "polling", "--source", help="polling | sse | replay (Phase 1 = polling)."
+    ),
+    payload_file: str | None = typer.Option(
+        None, "--payload-file", help="Optional JSON file with extra payload fields."
+    ),
+) -> None:
+    """Record that the caller is about to act on ``event_id``."""
+    from map_types.enums import InboundEventSource
+
+    from cli.main import _read_text_file, _run
+    from server.domain.schemas import InboundEventCreate
+
+    extra_payload: dict | None = None
+    if payload_file is not None:
+        extra_payload = json.loads(_read_text_file(Path(payload_file), kind="payload"))
+    payload = InboundEventCreate(
+        event_id=event_id,
+        event_type=event_type,
+        source=InboundEventSource(source),
+        fingerprint=fingerprint,
+        payload=extra_payload,
+    )
+
+    def action(c: MAPClient):
+        try:
+            return c.record_inbound_event(payload)
+        except MAPConflictError as exc:
+            typer.echo(f"inbound-event duplicate (409): {exc.detail}", err=True)
+            raise typer.Exit(2) from exc
+
+    _run(action)

cli/commands/persona.py

@@ -0,0 +1,63 @@
+"""``map persona ...`` sub-app — cli/main.py split.
+
+Local ``.map/agents.yaml`` identity commands.
+Command bodies lazy-import ``cli.main`` helpers to break the import cycle.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from map_client.client import MAPClient
+from map_client.project_config import find_map_dir, load_project_map_config
+
+persona_app = typer.Typer(help="Persona / identity commands")
+
+
+@persona_app.command("list")
+def persona_list(
+    project_root: Path | None = typer.Option(None, "--project-root"),
+) -> None:
+    """List personas defined in .map/agents.yaml."""
+    from cli.main import _print_json, _require_map_dir  # lazy: avoid cycle
+    map_dir = _require_map_dir(project_root)
+    cfg = load_project_map_config(map_dir=map_dir)
+    rows = []
+    for key, info in cfg.personas.items():
+        has_token = key in cfg.tokens
+        rows.append(
+            {
+                "persona": key,
+                "agent_name": info.agent_name,
+                "has_token": has_token,
+                "description": info.description,
+            }
+        )
+    _print_json(rows)
+
+
+@persona_app.command("whoami")
+def persona_whoami(
+    persona: str | None = typer.Option(None, "--persona", "-p"),
+    project_root: Path | None = typer.Option(None, "--project-root"),
+) -> None:
+    """Show MAP identity for the selected persona (default from .map/config.yaml)."""
+    from cli.main import _cli_options, _run  # lazy: avoid cycle
+    if persona is not None:
+        _cli_options["persona"] = persona
+    if project_root is not None:
+        _cli_options["project_root"] = project_root
+
+    def action(c: MAPClient):
+        me = c.get_me()
+        payload = me.model_dump(mode="json")
+        if _cli_options.get("persona"):
+            payload["persona"] = _cli_options["persona"]
+        elif find_map_dir(_cli_options.get("project_root")):
+            payload["persona"] = load_project_map_config(
+                project_root=_cli_options.get("project_root")
+            ).default_persona
+        return payload
+
+    _run(action)
+

cli/commands/project.py

@@ -0,0 +1,87 @@
+"""``map project ...`` sub-app — cli/main.py split.
+
+Command bodies lazy-import ``cli.main`` helpers to break the import cycle.
+"""
+from __future__ import annotations
+
+import uuid
+from pathlib import Path
+
+import typer
+from map_client.client import MAPClient
+
+from server.domain.schemas import ProjectStatusRevise
+
+project_app = typer.Typer(help="Project commands")
+status_app = typer.Typer(help="Project Current Status commands")
+project_app.add_typer(status_app, name="status")
+
+
+@project_app.command("create")
+def project_create(
+    key: str = typer.Option(..., "--key"),
+    name: str = typer.Option(..., "--name"),
+    path: str = typer.Option(..., "--path"),
+    description: str | None = typer.Option(None, "--description"),
+) -> None:
+    from cli.main import _run  # lazy: avoid cycle
+    _run(lambda c: c.create_project(key, name, path, description))
+
+
+@project_app.command("list")
+def project_list(include_archived: bool = typer.Option(False, "--include-archived")) -> None:
+    from cli.main import _run  # lazy: avoid cycle
+    _run(lambda c: c.list_projects(include_archived=include_archived))
+
+
+@project_app.command("decisions")
+def project_decisions(
+    project: uuid.UUID | None = typer.Option(None, "--project"),
+    project_key: str | None = typer.Option(None, "--project-key"),
+    limit: int = typer.Option(20, "--limit", min=1, max=100),
+) -> None:
+    from cli.main import _resolve_project, _run  # lazy: avoid cycle
+    def action(c: MAPClient):
+        pid = _resolve_project(c, project, project_key)
+        return c.list_project_decisions(pid, limit=limit)
+
+    _run(action)
+
+
+@status_app.command("revise")
+def project_status_revise(
+    status_file: Path = typer.Option(..., "--file"),
+    project: uuid.UUID | None = typer.Option(None, "--project"),
+    project_key: str | None = typer.Option(None, "--project-key"),
+    note: str | None = typer.Option(None, "--note"),
+) -> None:
+    from cli.main import _read_text_file, _resolve_project, _run  # lazy: avoid cycle
+    payload = ProjectStatusRevise(content_md=_read_text_file(status_file, kind="status"), change_note=note)
+
+    def action(c: MAPClient):
+        pid = _resolve_project(c, project, project_key)
+        return c.revise_project_status(pid, payload)
+
+    _run(action)
+
+
+@status_app.command("versions")
+def project_status_versions(
+    project: uuid.UUID | None = typer.Option(None, "--project"),
+    project_key: str | None = typer.Option(None, "--project-key"),
+) -> None:
+    from cli.main import _resolve_project, _run  # lazy: avoid cycle
+    _run(lambda c: c.list_project_status_versions(_resolve_project(c, project, project_key)))
+
+
+@status_app.command("show")
+def project_status_show(
+    version: int = typer.Option(..., "--version"),
+    project: uuid.UUID | None = typer.Option(None, "--project"),
+    project_key: str | None = typer.Option(None, "--project-key"),
+) -> None:
+    from cli.main import _resolve_project, _run  # lazy: avoid cycle
+    _run(
+        lambda c: c.get_project_status_version(_resolve_project(c, project, project_key), version)
+    )
+

cli/commands/runtime.py

@@ -0,0 +1,105 @@
+"""``map runtime ...`` sub-app — cli/main.py split.
+
+Command bodies lazy-import ``cli.main`` helpers to break the import cycle.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+runtime_app = typer.Typer(help="Agent runtime session commands")
+
+
+@runtime_app.command("chat")
+def runtime_chat(
+    persona: str = typer.Option(
+        "host",
+        "--persona",
+        "-p",
+        help="Persona whose runtime session to resume (default: host)",
+    ),
+    project_root: Path | None = typer.Option(
+        None,
+        "--project-root",
+        help="Repo root containing .map/ (default: search upward from cwd)",
+    ),
+    state_file: Path | None = typer.Option(
+        None,
+        "--state-file",
+        help="Runtime waker state file (default: .map/runtime-waker-state-<persona>.json)",
+    ),
+    runtime_home: Path | None = typer.Option(
+        None,
+        "--runtime-home",
+        help="Claude runtime HOME (default: .map/claude-runtime-home-<persona>)",
+    ),
+    session_id: str | None = typer.Option(
+        None,
+        "--session-id",
+        help="Resume a specific Claude session id (default: read from state file)",
+    ),
+    prompt: str | None = typer.Option(
+        None,
+        "--prompt",
+        help="Send one prompt before entering interactive REPL",
+    ),
+    new_session: bool = typer.Option(
+        False,
+        "--new-session",
+        help="Start a fresh Claude session instead of resuming state",
+    ),
+    ignore_waker: bool = typer.Option(
+        False,
+        "--ignore-waker",
+        help="Allow chat while map-runtime-waker is running (may conflict)",
+    ),
+    model: str | None = typer.Option(None, "--model", help="Optional Claude model override"),
+) -> None:
+    """Resume a persona runtime session and chat interactively from the terminal."""
+    from cli.main import _cli_options  # lazy: avoid cycle
+    from cli.runtime_chat import run_runtime_chat
+
+    run_runtime_chat(
+        persona=persona,
+        project_root=project_root or _cli_options.get("project_root"),
+        state_file=state_file,
+        runtime_home=runtime_home,
+        session_id=session_id,
+        new_session=new_session,
+        initial_prompt=prompt,
+        ignore_waker=ignore_waker,
+        model=model,
+    )
+
+
+@runtime_app.command("status")
+def runtime_status(
+    persona: str = typer.Option(
+        "host",
+        "--persona",
+        "-p",
+        help="Persona to inspect (default: host)",
+    ),
+    project_root: Path | None = typer.Option(
+        None,
+        "--project-root",
+        help="Repo root containing .map/ (default: search upward from cwd)",
+    ),
+    state_file: Path | None = typer.Option(
+        None,
+        "--state-file",
+        help="Runtime waker state file (default: .map/runtime-waker-state-<persona>.json)",
+    ),
+) -> None:
+    """Show resumable session id and whether runtime waker is running."""
+    from cli.main import _cli_options, _print_json  # lazy: avoid cycle
+    from cli.runtime_chat import dump_runtime_chat_status
+
+    _print_json(
+        dump_runtime_chat_status(
+            persona=persona,
+            project_root=project_root or _cli_options.get("project_root"),
+            state_file=state_file,
+        )
+    )