agentic-project-kit 1.0.1__py3-none-any.whl

agentic_project_kit/gui_tk_widgets.py

@@ -0,0 +1,177 @@
+from __future__ import annotations
+
+from typing import Any
+
+from agentic_project_kit.access_levels import ACCESS_LEVEL_ORDER
+from agentic_project_kit.gui_communication_modes import (
+    communication_mode_example as shared_communication_mode_example,
+    communication_mode_explanation as shared_communication_mode_explanation,
+    communication_mode_next_step_hint as shared_communication_mode_next_step_hint,
+    communication_mode_walkthrough_steps as shared_communication_mode_walkthrough_steps,
+)
+from agentic_project_kit.gui_viewmodel import CommunicationModeViewModel
+
+
+TRAFFIC_LIGHT_FILL_BY_COLOR = {
+    "green": "#1f883d",
+    "yellow": "#bf8700",
+    "red": "#cf222e",
+    "gray": "#6e7781",
+}
+
+TRAFFIC_LIGHT_LABEL_BY_STATE = {
+    "READY": "READY (green)",
+    "WAIT_FOR_D2": "WAIT_FOR_D2 (yellow)",
+    "WAIT": "WAIT (yellow)",
+    "BLOCKED": "BLOCKED (red)",
+    "FAILED": "FAILED (red)",
+}
+
+TOOLTIP_WRAP_LENGTH = 360
+TOOLTIP_SCREEN_MARGIN = 12
+
+
+def traffic_light_fill(color: str) -> str:
+    return TRAFFIC_LIGHT_FILL_BY_COLOR.get(color.lower(), TRAFFIC_LIGHT_FILL_BY_COLOR["gray"])
+
+
+def traffic_light_state_label(state: str) -> str:
+    normalized = state.strip().upper().replace("-", "_")
+    return TRAFFIC_LIGHT_LABEL_BY_STATE.get(normalized, f"{normalized or 'UNKNOWN'} (gray)")
+
+
+def communication_mode_explanation(mode: str) -> str:
+    return shared_communication_mode_explanation(mode)
+
+
+def communication_mode_example(mode: str) -> str:
+    return shared_communication_mode_example(mode)
+
+
+def communication_mode_next_step_hint(mode: str) -> str:
+    return shared_communication_mode_next_step_hint(mode)
+
+
+def communication_mode_walkthrough_steps(mode: str) -> tuple[str, ...]:
+    return shared_communication_mode_walkthrough_steps(mode)
+
+
+def communication_mode_option_label(mode: CommunicationModeViewModel) -> str:
+    return f"{mode.label}: {mode.role}"
+
+
+def communication_mode_option_values(
+    modes: tuple[CommunicationModeViewModel, ...],
+) -> tuple[str, ...]:
+    return tuple(communication_mode_option_label(mode) for mode in modes)
+
+
+def selected_communication_mode_option(
+    modes: tuple[CommunicationModeViewModel, ...],
+) -> str:
+    selected = next((mode for mode in modes if mode.selected), modes[0])
+    return communication_mode_option_label(selected)
+
+
+def access_level_option_values() -> tuple[str, ...]:
+    return tuple(ACCESS_LEVEL_ORDER)
+
+
+class TkTooltip:
+    def __init__(self, widget: Any, text: str, *, wraplength: int = TOOLTIP_WRAP_LENGTH) -> None:
+        self.widget = widget
+        self.text = text
+        self.wraplength = wraplength
+        self.window: Any | None = None
+        if hasattr(widget, "bind"):
+            widget.bind("<Enter>", self.show)
+            widget.bind("<Leave>", self.hide)
+
+    def show(self, _event: object | None = None) -> None:
+        if self.window is not None or not self.text:
+            return
+        import tkinter as tk
+
+        x = self.widget.winfo_rootx() + 18
+        y = self.widget.winfo_rooty() + self.widget.winfo_height() + 8
+        self.window = tk.Toplevel(self.widget)
+        self.window.wm_overrideredirect(True)
+        label = tk.Label(
+            self.window,
+            text=self.text,
+            justify="left",
+            background="#ffffe0",
+            relief="solid",
+            borderwidth=1,
+            padx=6,
+            pady=3,
+            wraplength=self.wraplength,
+        )
+        label.pack()
+        self.window.update_idletasks()
+        width = self.window.winfo_reqwidth()
+        height = self.window.winfo_reqheight()
+        screen_width = self.widget.winfo_screenwidth()
+        screen_height = self.widget.winfo_screenheight()
+        x, y = constrain_tooltip_position(
+            x=x,
+            y=y,
+            width=width,
+            height=height,
+            screen_width=screen_width,
+            screen_height=screen_height,
+        )
+        self.window.wm_geometry(f"+{x}+{y}")
+
+    def hide(self, _event: object | None = None) -> None:
+        if self.window is None:
+            return
+        self.window.destroy()
+        self.window = None
+
+    def update_text(self, text: str) -> None:
+        self.text = text
+
+
+def constrain_tooltip_position(
+    *,
+    x: int,
+    y: int,
+    width: int,
+    height: int,
+    screen_width: int,
+    screen_height: int,
+    margin: int = TOOLTIP_SCREEN_MARGIN,
+) -> tuple[int, int]:
+    max_x = max(margin, screen_width - width - margin)
+    max_y = max(margin, screen_height - height - margin)
+    return max(margin, min(x, max_x)), max(margin, min(y, max_y))
+
+
+def attach_tooltip(widget: Any, text: str) -> Any:
+    existing = getattr(widget, "_agentic_tooltip", None)
+    if isinstance(existing, TkTooltip):
+        existing.hide()
+        existing.update_text(text)
+        widget._agentic_tooltip_text = text
+        return widget
+    if existing is not None and hasattr(existing, "hide"):
+        existing.hide()
+    widget._agentic_tooltip_text = text
+    widget._agentic_tooltip = TkTooltip(widget, text)
+    return widget
+
+
+def maximize_root_window(root: Any, *, fallback_geometry: str) -> None:
+    if not hasattr(root, "geometry"):
+        return
+    try:
+        screen_width = int(root.winfo_screenwidth())
+        screen_height = int(root.winfo_screenheight())
+    except Exception:
+        root.geometry(fallback_geometry)
+        return
+    if screen_width <= 0 or screen_height <= 0:
+        root.geometry(fallback_geometry)
+        return
+    root.geometry(f"{screen_width}x{screen_height}+0+0")

agentic_project_kit/gui_tkinter_renderer.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Protocol
+
+from agentic_project_kit.gui_layout_plan import LayoutNode, LayoutPlan, build_layout_plan
+
+
+@dataclass(frozen=True)
+class RenderedWidget:
+    node_id: str
+    kind: str
+    label: str
+    parent: str
+    enabled: bool
+    command_id: str
+    tooltip: str
+    icon_id: str
+    category: str
+    implementation_state: str
+    disabled_reason: str
+
+
+@dataclass(frozen=True)
+class TkinterRenderResult:
+    title: str
+    geometry: str
+    widgets: tuple[RenderedWidget, ...]
+    destructive_enabled: bool
+
+    def widgets_by_kind(self, kind: str) -> tuple[RenderedWidget, ...]:
+        return tuple(widget for widget in self.widgets if widget.kind == kind)
+
+
+class TkRootLike(Protocol):
+    def title(self, value: str) -> Any: ...
+    def geometry(self, value: str) -> Any: ...
+
+
+def _as_widget(node: LayoutNode) -> RenderedWidget:
+    return RenderedWidget(
+        node.node_id,
+        node.kind,
+        node.label,
+        node.parent,
+        node.enabled,
+        node.command_id,
+        node.tooltip,
+        node.icon_id,
+        node.category,
+        node.implementation_state,
+        node.disabled_reason,
+    )
+
+
+def render_layout_to_tkinter(
+    root: TkRootLike, plan: LayoutPlan | None = None
+) -> TkinterRenderResult:
+    current_plan = build_layout_plan() if plan is None else plan
+    root.title(current_plan.title)
+    root.geometry(current_plan.geometry)
+    widgets = tuple(_as_widget(node) for node in current_plan.nodes)
+    destructive_enabled = any(
+        widget.command_id == "release-publish" and widget.enabled for widget in widgets
+    )
+    return TkinterRenderResult(
+        current_plan.title, current_plan.geometry, widgets, destructive_enabled
+    )
+
+
+def render_tkinter_result_summary(result: TkinterRenderResult) -> str:
+    lines = [
+        "TKINTER RENDER RESULT",
+        f"title={result.title}",
+        f"geometry={result.geometry}",
+        f"widget_count={len(result.widgets)}",
+    ]
+    for kind in ("menu", "toolbar_button", "action_button", "output_panel", "summary_bar"):
+        lines.append(f"{kind}_count={len(result.widgets_by_kind(kind))}")
+    categories = sorted(
+        {widget.category for widget in result.widgets_by_kind("action_button") if widget.category}
+    )
+    lines.append("action_categories=" + (",".join(categories) if categories else "NONE"))
+    disabled = [widget.command_id for widget in result.widgets if not widget.enabled]
+    lines.append("disabled_commands=" + (",".join(disabled) if disabled else "NONE"))
+    lines.append(f"destructive_enabled={str(result.destructive_enabled).lower()}")
+    return "\n".join(lines)