patchbai 0.1.0__py3-none-any.whl

patchbai/config.py

@@ -0,0 +1,128 @@
+import logging
+import tomllib
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+import tomli_w
+
+log = logging.getLogger(__name__)
+
+
+_DEFAULT_BINDINGS = {
+    "/":      ("focus_command_bar", {}),
+    "ctrl+q": ("quit", {}),
+    "ctrl+h": ("open_history", {}),
+    "ctrl+l": ("open_layout_switcher", {}),
+    "?":      ("show_help", {}),
+}
+
+
+@dataclass
+class KeyBinding:
+    action: str
+    args: dict = field(default_factory=dict)
+
+
+@dataclass
+class UISection:
+    active_theme: str = "default"
+    default_model: str = ""
+
+
+@dataclass
+class WidgetsSection:
+    local_dir_enabled: bool = True
+
+
+@dataclass
+class Config:
+    bindings: dict[str, KeyBinding] = field(default_factory=dict)
+    ui: UISection = field(default_factory=UISection)
+    widgets: WidgetsSection = field(default_factory=WidgetsSection)
+
+    def get_path(self, path: str) -> Any:
+        section, attr = self._split_path(path)
+        section_obj = getattr(self, section, None)
+        if section_obj is None or not hasattr(section_obj, attr):
+            raise KeyError(path)
+        return getattr(section_obj, attr)
+
+    def set_path(self, path: str, value: Any) -> None:
+        section, attr = self._split_path(path)
+        section_obj = getattr(self, section, None)
+        if section_obj is None or not hasattr(section_obj, attr):
+            raise KeyError(path)
+        setattr(section_obj, attr, value)
+
+    @staticmethod
+    def _split_path(path: str) -> tuple[str, str]:
+        parts = path.split(".")
+        if len(parts) != 2:
+            raise KeyError(f"only dotted two-segment paths supported, got {path!r}")
+        return parts[0], parts[1]
+
+
+class ConfigStore:
+    """Read/write ~/.config/patchbai/config.toml. Defaults applied on missing file."""
+
+    def __init__(self, global_dir: Path) -> None:
+        self._dir = Path(global_dir)
+        self._path = self._dir / "config.toml"
+
+    def load(self) -> Config:
+        cfg = Config()
+        # Apply defaults first.
+        for key, (action, args) in _DEFAULT_BINDINGS.items():
+            cfg.bindings[key] = KeyBinding(action=action, args=dict(args))
+
+        if not self._path.exists():
+            return cfg
+
+        try:
+            raw = tomllib.loads(self._path.read_text(encoding="utf-8"))
+        except Exception:
+            log.exception("Failed to parse config.toml; using defaults")
+            return cfg
+
+        # Merge bindings (overrides defaults).
+        bindings_raw = raw.get("bindings", {})
+        if isinstance(bindings_raw, dict):
+            for key, val in bindings_raw.items():
+                if isinstance(val, dict) and "action" in val:
+                    cfg.bindings[key] = KeyBinding(
+                        action=val["action"], args=dict(val.get("args", {}))
+                    )
+
+        ui_raw = raw.get("ui", {})
+        if isinstance(ui_raw, dict):
+            if "active_theme" in ui_raw and isinstance(ui_raw["active_theme"], str):
+                cfg.ui.active_theme = ui_raw["active_theme"]
+            if "default_model" in ui_raw and isinstance(ui_raw["default_model"], str):
+                cfg.ui.default_model = ui_raw["default_model"]
+            # Legacy `ui.theme` key (now removed) is silently ignored.
+
+        widgets_raw = raw.get("widgets", {})
+        if isinstance(widgets_raw, dict):
+            if "local_dir_enabled" in widgets_raw and isinstance(
+                widgets_raw["local_dir_enabled"], bool
+            ):
+                cfg.widgets.local_dir_enabled = widgets_raw["local_dir_enabled"]
+        return cfg
+
+    def save(self, cfg: Config) -> None:
+        self._dir.mkdir(parents=True, exist_ok=True)
+        out = {
+            "bindings": {
+                key: {"action": b.action, "args": b.args}
+                for key, b in cfg.bindings.items()
+            },
+            "ui": {
+                "active_theme": cfg.ui.active_theme,
+                "default_model": cfg.ui.default_model,
+            },
+            "widgets": {
+                "local_dir_enabled": cfg.widgets.local_dir_enabled,
+            },
+        }
+        self._path.write_text(tomli_w.dumps(out), encoding="utf-8")

patchbai/events.py

@@ -0,0 +1,236 @@
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Callable, TypeVar
+
+from patchbai.agents.state import AgentInfo, AgentState
+
+if TYPE_CHECKING:
+    from patchbai.layout.spec import LayoutSpec
+
+log = logging.getLogger(__name__)
+
+E = TypeVar("E")
+Handler = Callable[[E], None]
+Unsubscribe = Callable[[], None]
+
+
+# --- Built-in event types (more added by later plans) ----------------------
+
+@dataclass(frozen=True)
+class UserMessageToOrchestrator:
+    """User typed something into the orchestrator chat or command bar."""
+    text: str
+
+
+@dataclass(frozen=True)
+class OrchestratorReply:
+    """The orchestrator session emitted a reply."""
+    text: str
+
+
+@dataclass(frozen=True)
+class OrchestratorSessionSwitched:
+    """The orchestrator session was swapped (via /reset or /resume)."""
+    session_id: str
+    transcript_path: str
+
+
+@dataclass(frozen=True)
+class OpenResumePicker:
+    """Request from the orchestrator that the app open the resume modal."""
+    pass
+
+
+@dataclass(frozen=True)
+class StatsUpdated:
+    """StatusBar stats refresh."""
+    tokens_in: int = 0
+    tokens_out: int = 0
+    cost: float = 0.0
+    active_agents: int = 0
+
+
+# --- Agent event types -----------------------------------------------------
+
+@dataclass(frozen=True)
+class AgentSpawned:
+    """A new child agent has been created and registered with AgentManager."""
+    info: AgentInfo
+
+
+@dataclass(frozen=True)
+class AgentStateChanged:
+    """An agent transitioned between states (e.g., RUNNING → DONE)."""
+    info: AgentInfo
+    old_state: AgentState
+
+
+@dataclass(frozen=True)
+class AgentTokensTouched:
+    """An AgentSession (orchestrator inner session or child agent) just
+    accumulated tokens / cost from a ResultMessage. Lightweight signal — no
+    deltas, no totals; subscribers re-aggregate from the canonical AgentInfo
+    objects."""
+    agent_id: str
+
+
+@dataclass(frozen=True)
+class AgentMessageAppended:
+    """A new message landed in an agent's transcript."""
+    agent_id: str
+    role: str  # "user" | "assistant" | "tool_use" | "tool_result" | "thinking" | "system"
+    text: str
+    tool_id: str | None = None       # set for role in {"tool_use", "tool_result"}
+    tool_name: str | None = None     # set for role == "tool_use"
+
+
+# Forward-declared for plan 3; the handler arrives later.
+@dataclass(frozen=True)
+class AgentRequestedUserInput:
+    """A child agent called ask_orchestrator and is blocked waiting on a reply."""
+    agent_id: str
+    question: str
+    request_id: str
+
+
+@dataclass(frozen=True)
+class AgentNotifiedOrchestrator:
+    """A child agent called notify_orchestrator (fire-and-forget)."""
+    agent_id: str
+    message: str
+
+
+@dataclass(frozen=True)
+class AgentArchiveChanged:
+    """An agent's `archived` flag was toggled. Carries a frozen snapshot of
+    the AgentInfo so subscribers (AgentTable, persistence) can refresh."""
+    info: AgentInfo
+
+
+@dataclass(frozen=True)
+class DirectMessageToAgent:
+    """User typed directly to a focused AgentTranscript's input."""
+    agent_id: str
+    text: str
+
+
+# --- Layout event types ----------------------------------------------------
+
+@dataclass(frozen=True)
+class LayoutApplied:
+    """The LayoutEngine successfully applied a new spec."""
+    spec: "LayoutSpec"
+    layout_name: str | None = None  # if loaded by name; else None
+    tab_id: str | None = None  # set when published per-tab
+
+
+@dataclass(frozen=True)
+class LayoutFailed:
+    """The LayoutEngine rejected a spec at build time."""
+    error: str
+    tab_id: str | None = None
+
+
+@dataclass(frozen=True)
+class LayoutResized:
+    """User finished a mouse-drag resize on a Splitter between two siblings.
+
+    Carries the parent container's post-drag layout state as a tuple of
+    `outer_size` cell counts — one entry per *non-splitter* child, in spec
+    order. The app handler renormalizes those cells into percentages that
+    sum to 100%, which keeps the layout converged across re-saves instead of
+    drifting (the previous design rounded each pair independently using
+    inner widths and was off by border + splitter cells per drag)."""
+    tab_id: str
+    parent_path: tuple[int, ...]
+    children_cells: tuple[int, ...]
+
+
+@dataclass(frozen=True)
+class TabAdded:
+    tab_id: str
+    title: str
+
+
+@dataclass(frozen=True)
+class TabClosed:
+    tab_id: str
+
+
+@dataclass(frozen=True)
+class TabSwitched:
+    tab_id: str
+    title: str
+
+
+@dataclass(frozen=True)
+class WorkspaceCwdChanged:
+    """The app's working directory has been re-rooted at runtime. The
+    workspace state has already been reloaded from `cwd` and the active
+    layout re-applied; subscribers should re-render any cwd-dependent UI."""
+    cwd: str
+
+
+@dataclass(frozen=True)
+class FileSelected:
+    """A FileTree (or similar) widget selected a file. Other widgets like
+    FileViewer can subscribe with `follow_selection=True` to react."""
+    path: str
+
+
+@dataclass(frozen=True)
+class ActivityLogged:
+    """A new entry was appended to the app's ActivityLog. Subscribers (e.g.,
+    ActivityFeed widgets) consume this to render the new entry. The `entry`
+    field is an `ActivityEntry` from `patchbai.activity.log`; we leave it
+    typed as `object` here to avoid a circular import."""
+    entry: object
+
+
+@dataclass(frozen=True)
+class AgentFocusRequested:
+    """An ActivityFeed row click (or other UI affordance) wants to focus a
+    specific agent. AgentTable subscribes and selects + scrolls to the
+    matching row; if no AgentTable is mounted the click handler falls back
+    to opening the agent's TranscriptScreen."""
+    agent_id: str
+
+
+# --- The bus ---------------------------------------------------------------
+
+class EventBus:
+    """Synchronous in-process pub/sub keyed by event class.
+
+    Handlers are called in subscription order. Handler exceptions are logged
+    and swallowed so one bad handler can't take down the others.
+    """
+
+    def __init__(self) -> None:
+        self._subs: dict[type, list[Callable]] = {}
+
+    def subscribe(self, event_type: type[E], handler: Callable[[E], None]) -> Unsubscribe:
+        self._subs.setdefault(event_type, []).append(handler)
+
+        def unsubscribe() -> None:
+            handlers = self._subs.get(event_type)
+            if handlers and handler in handlers:
+                handlers.remove(handler)
+
+        return unsubscribe
+
+    def publish(self, event: object) -> None:
+        """Dispatch `event` to all current subscribers of `type(event)`.
+
+        Handlers are called on a snapshot of the subscriber list, so handlers
+        that unsubscribe during dispatch do not interfere with the current
+        publish — their removal takes effect on subsequent publishes.
+
+        Subscribers of subclasses are NOT matched (exact-type dispatch only).
+        """
+        for handler in list(self._subs.get(type(event), [])):
+            try:
+                handler(event)
+            except Exception:
+                log.exception("EventBus handler raised")

patchbai/layout/custom_widgets.py

@@ -0,0 +1,82 @@
+from textual.widget import Widget
+
+from patchbai.layout.registry import WidgetRegistry
+
+
+class CustomWidgetError(Exception):
+    """Raised when a custom-widget source can't be exec'd or doesn't yield
+    a usable Widget subclass."""
+
+
+def register_custom_widget(
+    registry: WidgetRegistry,
+    name: str,
+    source: str,
+    *,
+    description: str = "",
+    props_schema: dict | None = None,
+) -> None:
+    """Exec `source` in an isolated namespace and register the resulting
+    Widget subclass under `name`.
+
+    Class detection precedence:
+      1. `WIDGET_CLASS = SomeClass` sentinel in the namespace.
+      2. A class named exactly `name`.
+      3. A single Widget subclass defined in the source.
+      Otherwise CustomWidgetError.
+
+    The namespace is empty — the source is expected to import what it
+    needs from `textual.*` and stdlib.
+    """
+    namespace: dict = {}
+    try:
+        exec(source, namespace)  # noqa: S102 - intentional, in-process trust model
+    except Exception as e:
+        raise CustomWidgetError(f"failed to exec source for {name!r}: {e}") from e
+
+    cls = _find_widget_class(namespace, name)
+    if cls is None:
+        raise CustomWidgetError(
+            f"no Widget subclass found in source for {name!r}"
+        )
+
+    # Drop any prior registration so the new class is the live one.
+    registry.unregister(name)
+    registry.register(
+        name, cls,
+        description=description,
+        props_schema=props_schema or {},
+        source="inline",
+    )
+
+
+def _find_widget_class(namespace: dict, name: str) -> type[Widget] | None:
+    sentinel = namespace.get("WIDGET_CLASS")
+    if isinstance(sentinel, type) and issubclass(sentinel, Widget):
+        return sentinel
+
+    by_name = namespace.get(name)
+    if isinstance(by_name, type) and issubclass(by_name, Widget):
+        return by_name
+
+    # Find Widget subclasses DEFINED in this exec (not imported).
+    # exec'd classes get __module__ == "builtins" by default since the
+    # exec namespace has no __name__.
+    candidates = [
+        v for v in namespace.values()
+        if isinstance(v, type)
+        and issubclass(v, Widget)
+        and v is not Widget
+        and v.__module__ == "builtins"
+    ]
+    # Deduplicate by id (same class can appear under multiple names).
+    unique = list({id(c): c for c in candidates}.values())
+
+    if len(unique) == 1:
+        return unique[0]
+    if len(unique) > 1:
+        raise CustomWidgetError(
+            f"ambiguous: source defined {len(unique)} Widget subclasses; "
+            f"set WIDGET_CLASS = ... or name one class {name!r} to disambiguate"
+        )
+    return None

patchbai/layout/defaults.py

@@ -0,0 +1,33 @@
+from patchbai.layout.spec import LayoutSpec
+
+
+def dashboard_layout() -> LayoutSpec:
+    """The built-in landing layout used when no <cwd>/.patchbai/layout.json exists.
+
+    Mirrors the saved 'focused-agents' layout: orchestrator at 60%, with the
+    agent table and activity feed sharing a tabs container at 40% (Agents
+    active by default) so the activity feed doesn't compete for vertical
+    space when the agent table is what the user usually wants to see.
+    """
+    return LayoutSpec.model_validate({
+        "version": 1,
+        "layout": {
+            "type": "horizontal",
+            "children": [
+                {"id": "orch", "size": "60%", "widget": "OrchestratorChat",
+                 "title": "Orchestrator"},
+                {
+                    "type": "tabs",
+                    "size": "40%",
+                    "children": [
+                        {"id": "agents", "widget": "AgentTable",
+                         "title": "Agents"},
+                        {"id": "feed", "widget": "ActivityFeed",
+                         "title": "Activity"},
+                    ],
+                    "active": "agents",
+                },
+            ],
+        },
+        "focus": "orch",
+    })