patchfeld 0.2.0__py3-none-any.whl

patchfeld/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.1"

patchfeld/__main__.py

@@ -0,0 +1,32 @@
+import argparse
+import sys
+
+from patchfeld.app import PatchfeldApp
+
+
+def _parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        prog="patchfeld",
+        description="Multi-agent Textual TUI for Claude Agent SDK.",
+    )
+    parser.add_argument(
+        "--bypass-permissions",
+        action="store_true",
+        help=(
+            "Run all sessions (orchestrator + child agents) with "
+            "permission_mode=bypassPermissions. Default behavior is to "
+            "ask for confirmation via a Textual modal before every "
+            "tool call."
+        ),
+    )
+    return parser.parse_args(argv)
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = _parse_args(argv if argv is not None else sys.argv[1:])
+    PatchfeldApp(bypass_permissions=args.bypass_permissions).run()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

patchfeld/actions.py

@@ -0,0 +1,34 @@
+from dataclasses import dataclass
+from typing import Any, Callable
+
+
+@dataclass(frozen=True)
+class ActionSpec:
+    name: str
+    callable: Callable
+    description: str
+    args_schema: dict
+
+
+class ActionRegistry:
+    """Enumerable action registry — name → ActionSpec."""
+
+    def __init__(self) -> None:
+        self._actions: dict[str, ActionSpec] = {}
+
+    def register(self, name: str, fn: Callable, *, description: str, args_schema: dict) -> None:
+        self._actions[name] = ActionSpec(
+            name=name, callable=fn, description=description, args_schema=args_schema,
+        )
+
+    def get(self, name: str) -> ActionSpec:
+        if name not in self._actions:
+            raise KeyError(f"unknown action: {name}")
+        return self._actions[name]
+
+    def list(self) -> list[ActionSpec]:
+        return sorted(self._actions.values(), key=lambda s: s.name)
+
+    def invoke(self, name: str, args: dict) -> Any:
+        spec = self.get(name)
+        return spec.callable(**(args or {}))

patchfeld/activity/log.py

@@ -0,0 +1,237 @@
+from __future__ import annotations
+
+from collections import deque
+from dataclasses import dataclass
+from datetime import datetime
+
+
+class ActivityKind:
+    """String constants for entry kinds. Plain class instead of an Enum so
+    `entry.kind == ActivityKind.AGENT_SPAWNED` and `entry.kind == "agent.spawned"`
+    are both valid — keeps test tables and the mode-filter dict ergonomic."""
+
+    AGENT_SPAWNED = "agent.spawned"
+    AGENT_STATE = "agent.state"
+    AGENT_DONE = "agent.done"
+    AGENT_MESSAGE = "agent.message"
+    AGENT_TOOL = "agent.tool"
+    AGENT_ASK = "agent.ask"
+    AGENT_NOTIFY = "agent.notify"
+    AGENT_ARCHIVE = "agent.archive"
+    ORCH_USER = "orch.user"
+    ORCH_REPLY = "orch.reply"
+    ORCH_SESSION = "orch.session"
+    LAYOUT_APPLIED = "layout.applied"
+    LAYOUT_FAILED = "layout.failed"
+    TAB_ADDED = "tab.added"
+    TAB_CLOSED = "tab.closed"
+    TAB_SWITCHED = "tab.switched"
+    WORKSPACE_CWD = "workspace.cwd"
+    FILE_SELECTED = "file.selected"
+
+
+@dataclass(frozen=True)
+class ActivityEntry:
+    """One normalized record in the ActivityLog. `kind` is one of the
+    ActivityKind dotted-string constants; `raw` is the original event object
+    for debugging/forensics."""
+    timestamp: datetime
+    kind: str
+    summary: str
+    detail: str | None
+    agent_id: str | None
+    tab_id: str | None
+    raw: object
+
+
+from patchfeld.events import (  # noqa: E402 — deferred to avoid circular import
+    ActivityLogged, AgentArchiveChanged, AgentMessageAppended,
+    AgentNotifiedOrchestrator, AgentRequestedUserInput, AgentSpawned,
+    AgentStateChanged, EventBus, FileSelected, LayoutApplied, LayoutFailed,
+    OrchestratorReply, OrchestratorSessionSwitched, TabAdded, TabClosed,
+    TabSwitched, UserMessageToOrchestrator, WorkspaceCwdChanged,
+)
+
+
+class ActivityLog:
+    """App-singleton capture of curated EventBus events. Stores the last 500
+    normalized entries in a deque. Publishes ActivityLogged after every
+    append so subscribers can react incrementally without re-walking the
+    backlog. Mode filtering is the consumer's responsibility — the log
+    captures the union."""
+
+    BUFFER_SIZE = 500
+
+    def __init__(self, bus: EventBus) -> None:
+        self._bus = bus
+        self._entries: deque[ActivityEntry] = deque(maxlen=self.BUFFER_SIZE)
+        self._wire_subscriptions(bus)
+
+    def entries(self) -> tuple[ActivityEntry, ...]:
+        """Snapshot of current entries, oldest first."""
+        return tuple(self._entries)
+
+    # --- subscriptions -----------------------------------------------------
+
+    def _wire_subscriptions(self, bus: EventBus) -> None:
+        bus.subscribe(AgentSpawned, self._on_agent_spawned)
+        bus.subscribe(AgentStateChanged, self._on_agent_state)
+        bus.subscribe(AgentMessageAppended, self._on_agent_message)
+        bus.subscribe(AgentRequestedUserInput, self._on_agent_ask)
+        bus.subscribe(AgentNotifiedOrchestrator, self._on_agent_notify)
+        bus.subscribe(AgentArchiveChanged, self._on_agent_archive)
+        bus.subscribe(UserMessageToOrchestrator, self._on_orch_user)
+        bus.subscribe(OrchestratorReply, self._on_orch_reply)
+        bus.subscribe(OrchestratorSessionSwitched, self._on_orch_session)
+        bus.subscribe(LayoutApplied, self._on_layout_applied)
+        bus.subscribe(LayoutFailed, self._on_layout_failed)
+        bus.subscribe(TabAdded, self._on_tab_added)
+        bus.subscribe(TabClosed, self._on_tab_closed)
+        bus.subscribe(TabSwitched, self._on_tab_switched)
+        bus.subscribe(WorkspaceCwdChanged, self._on_cwd_changed)
+        bus.subscribe(FileSelected, self._on_file_selected)
+
+    def _on_agent_spawned(self, event: AgentSpawned) -> None:
+        info = event.info
+        self._append(
+            kind=ActivityKind.AGENT_SPAWNED,
+            summary=f"{info.name} spawned",
+            detail=f"cwd: {info.cwd}",
+            agent_id=info.id,
+            tab_id=None,
+            raw=event,
+        )
+
+    def _on_agent_state(self, event: AgentStateChanged) -> None:
+        info = event.info
+        kind = ActivityKind.AGENT_DONE if info.state.is_terminal else ActivityKind.AGENT_STATE
+        summary = f"{info.name}: {event.old_state.value} → {info.state.value}"
+        self._append(
+            kind=kind, summary=summary, detail=None,
+            agent_id=info.id, tab_id=None, raw=event,
+        )
+
+    def _on_agent_message(self, event: AgentMessageAppended) -> None:
+        if event.role in ("user", "assistant"):
+            kind = ActivityKind.AGENT_MESSAGE
+            detail = event.text
+        elif event.role in ("tool_use", "tool_result"):
+            kind = ActivityKind.AGENT_TOOL
+            detail = event.tool_name or event.text
+        else:
+            return  # thinking/system are not surfaced in the feed
+        self._append(
+            kind=kind,
+            summary=event.agent_id,
+            detail=detail,
+            agent_id=event.agent_id,
+            tab_id=None,
+            raw=event,
+        )
+
+    def _on_agent_ask(self, event: AgentRequestedUserInput) -> None:
+        self._append(
+            kind=ActivityKind.AGENT_ASK,
+            summary=event.agent_id,
+            detail=event.question,
+            agent_id=event.agent_id,
+            tab_id=None,
+            raw=event,
+        )
+
+    def _on_agent_notify(self, event: AgentNotifiedOrchestrator) -> None:
+        self._append(
+            kind=ActivityKind.AGENT_NOTIFY,
+            summary=event.agent_id,
+            detail=event.message,
+            agent_id=event.agent_id,
+            tab_id=None,
+            raw=event,
+        )
+
+    def _on_agent_archive(self, event: AgentArchiveChanged) -> None:
+        info = event.info
+        self._append(
+            kind=ActivityKind.AGENT_ARCHIVE,
+            summary=f"{info.name} {'archived' if info.archived else 'unarchived'}",
+            detail=None,
+            agent_id=info.id,
+            tab_id=None,
+            raw=event,
+        )
+
+    def _on_orch_user(self, event: UserMessageToOrchestrator) -> None:
+        self._append(
+            kind=ActivityKind.ORCH_USER, summary="user → orchestrator",
+            detail=event.text, agent_id=None, tab_id=None, raw=event,
+        )
+
+    def _on_orch_reply(self, event: OrchestratorReply) -> None:
+        self._append(
+            kind=ActivityKind.ORCH_REPLY, summary="orchestrator → user",
+            detail=event.text, agent_id=None, tab_id=None, raw=event,
+        )
+
+    def _on_orch_session(self, event: OrchestratorSessionSwitched) -> None:
+        self._append(
+            kind=ActivityKind.ORCH_SESSION,
+            summary=f"session → {event.session_id[:8]}",
+            detail=event.transcript_path, agent_id=None, tab_id=None, raw=event,
+        )
+
+    def _on_layout_applied(self, event: LayoutApplied) -> None:
+        self._append(
+            kind=ActivityKind.LAYOUT_APPLIED,
+            summary=event.layout_name or "(unnamed)",
+            detail=None, agent_id=None, tab_id=event.tab_id, raw=event,
+        )
+
+    def _on_layout_failed(self, event: LayoutFailed) -> None:
+        self._append(
+            kind=ActivityKind.LAYOUT_FAILED, summary="layout failed",
+            detail=event.error, agent_id=None, tab_id=event.tab_id, raw=event,
+        )
+
+    def _on_tab_added(self, event: TabAdded) -> None:
+        self._append(
+            kind=ActivityKind.TAB_ADDED, summary=event.title, detail=None,
+            agent_id=None, tab_id=event.tab_id, raw=event,
+        )
+
+    def _on_tab_closed(self, event: TabClosed) -> None:
+        self._append(
+            kind=ActivityKind.TAB_CLOSED, summary=event.tab_id, detail=None,
+            agent_id=None, tab_id=event.tab_id, raw=event,
+        )
+
+    def _on_tab_switched(self, event: TabSwitched) -> None:
+        self._append(
+            kind=ActivityKind.TAB_SWITCHED, summary=event.title, detail=None,
+            agent_id=None, tab_id=event.tab_id, raw=event,
+        )
+
+    def _on_cwd_changed(self, event: WorkspaceCwdChanged) -> None:
+        self._append(
+            kind=ActivityKind.WORKSPACE_CWD, summary=event.cwd, detail=None,
+            agent_id=None, tab_id=None, raw=event,
+        )
+
+    def _on_file_selected(self, event: FileSelected) -> None:
+        self._append(
+            kind=ActivityKind.FILE_SELECTED, summary=event.path, detail=None,
+            agent_id=None, tab_id=None, raw=event,
+        )
+
+    # --- append ------------------------------------------------------------
+
+    def _append(
+        self, *, kind: str, summary: str, detail: str | None,
+        agent_id: str | None, tab_id: str | None, raw: object,
+    ) -> None:
+        entry = ActivityEntry(
+            timestamp=datetime.now(),
+            kind=kind, summary=summary, detail=detail,
+            agent_id=agent_id, tab_id=tab_id, raw=raw,
+        )
+        self._entries.append(entry)
+        self._bus.publish(ActivityLogged(entry=entry))

patchfeld/agents/child_tools.py

@@ -0,0 +1,66 @@
+import asyncio
+
+from claude_agent_sdk import create_sdk_mcp_server, tool
+
+from patchfeld.agents.request_inbox import RequestInbox
+from patchfeld.events import (
+    AgentNotifiedOrchestrator,
+    AgentRequestedUserInput,
+    EventBus,
+)
+
+
+def build_child_tools(*, agent_id: str, bus: EventBus, inbox: RequestInbox):
+    """Return (notify_handler, ask_handler) — bare async callables for unit tests."""
+
+    async def notify_orchestrator(args: dict) -> dict:
+        message = args["message"]
+        bus.publish(AgentNotifiedOrchestrator(agent_id=agent_id, message=message))
+        return {"content": [{"type": "text", "text": "Notification delivered."}]}
+
+    async def ask_orchestrator(args: dict) -> dict:
+        question = args["question"]
+        timeout_s = float(args.get("timeout_s", 300))
+        request_id = inbox.register()
+        bus.publish(
+            AgentRequestedUserInput(
+                agent_id=agent_id, question=question, request_id=request_id
+            )
+        )
+        try:
+            response = await inbox.wait(request_id, timeout_s=timeout_s)
+            return {"content": [{"type": "text", "text": response}]}
+        except asyncio.TimeoutError:
+            return {
+                "content": [
+                    {
+                        "type": "text",
+                        "text": (
+                            f"ask_orchestrator timed out after {timeout_s}s "
+                            "with no response."
+                        ),
+                    }
+                ]
+            }
+
+    return notify_orchestrator, ask_orchestrator
+
+
+def build_child_mcp_server(*, agent_id: str, bus: EventBus, inbox: RequestInbox):
+    notify_h, ask_h = build_child_tools(agent_id=agent_id, bus=bus, inbox=inbox)
+    notify = tool(
+        "notify_orchestrator",
+        "Send a fire-and-forget notification to the orchestrator.",
+        {"message": str},
+    )(notify_h)
+    ask = tool(
+        "ask_orchestrator",
+        (
+            "Ask the orchestrator a question and block until they respond. "
+            "Optional timeout_s defaults to 300 seconds."
+        ),
+        {"question": str},  # timeout_s is optional, not in schema
+    )(ask_h)
+    return create_sdk_mcp_server(
+        name="patchfeld_child", version="1.0.0", tools=[notify, ask]
+    )

patchfeld/agents/fake_sdk_adapter.py

@@ -0,0 +1,45 @@
+from typing import AsyncIterator
+
+from claude_agent_sdk import ClaudeAgentOptions
+
+
+class FakeSDKAdapter:
+    """Replays canned message streams. One script per expected query call."""
+
+    def __init__(self, scripts: list[list[object]]) -> None:
+        self._scripts = scripts
+        self._next_query_index = 0
+        self._pending: list[object] = []
+        self._started = False
+
+    async def start(self, *, options: ClaudeAgentOptions) -> None:
+        self._started = True
+
+    async def query(self, prompt: str) -> None:
+        assert self._started, "start() must be called before query()"
+        if self._next_query_index >= len(self._scripts):
+            raise IndexError(
+                f"FakeSDKAdapter has no script for query #{self._next_query_index} "
+                f"(only {len(self._scripts)} provided)"
+            )
+        self._pending = list(self._scripts[self._next_query_index])
+        self._next_query_index += 1
+
+    def stream(self) -> AsyncIterator[object]:
+        # Snapshot _pending into a local so calling stream() then mutating
+        # _pending mid-iteration doesn't cause skipping.
+        msgs = self._pending
+        self._pending = []
+
+        async def _agen() -> AsyncIterator[object]:
+            for m in msgs:
+                yield m
+
+        return _agen()
+
+    async def interrupt(self) -> None:
+        # No-op for the fake.
+        return
+
+    async def stop(self) -> None:
+        self._started = False