iac-code 0.1.0__py3-none-any.whl

iac_code/types/stream_events.py

@@ -0,0 +1,227 @@
+"""Fine-grained streaming event types for Provider -> AgentLoop -> Renderer pipeline.
+
+Replaces the old coarse-grained events (TextChunkEvent, ThinkingEvent, etc.).
+These events flow from Provider through AgentLoop to Renderer unchanged.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass, field
+from typing import Any, Literal, Union
+
+
+@dataclass
+class Usage:
+    """Token usage from an API response."""
+
+    input_tokens: int = 0
+    output_tokens: int = 0
+    cache_creation_input_tokens: int = 0
+    cache_read_input_tokens: int = 0
+
+    @property
+    def total_tokens(self) -> int:
+        return self.input_tokens + self.output_tokens + self.cache_creation_input_tokens + self.cache_read_input_tokens
+
+
+# -- Provider-originated events ------------------------------------------------
+
+
+@dataclass
+class MessageStartEvent:
+    """A new assistant message has started."""
+
+    message_id: str
+    type: Literal["message_start"] = "message_start"
+
+
+@dataclass
+class TextDeltaEvent:
+    """Incremental text content from the model."""
+
+    text: str
+    type: Literal["text_delta"] = "text_delta"
+
+
+@dataclass
+class ThinkingDeltaEvent:
+    """Incremental thinking/reasoning content."""
+
+    text: str
+    type: Literal["thinking_delta"] = "thinking_delta"
+
+
+@dataclass
+class ToolUseStartEvent:
+    """A tool call has started -- name is known, input not yet complete."""
+
+    tool_use_id: str
+    name: str
+    type: Literal["tool_use_start"] = "tool_use_start"
+
+
+@dataclass
+class ToolInputDeltaEvent:
+    """Incremental JSON input for a tool call."""
+
+    tool_use_id: str
+    partial_json: str
+    type: Literal["tool_input_delta"] = "tool_input_delta"
+
+
+@dataclass
+class ToolUseEndEvent:
+    """Tool call input is complete."""
+
+    tool_use_id: str
+    input: dict[str, Any]
+    type: Literal["tool_use_end"] = "tool_use_end"
+
+
+@dataclass
+class MessageEndEvent:
+    """The assistant message is complete."""
+
+    stop_reason: str
+    usage: Usage
+    type: Literal["message_end"] = "message_end"
+
+
+@dataclass
+class TombstoneEvent:
+    """Mark a previously-yielded message as orphaned (should be removed from UI/transcript)."""
+
+    message_id: str
+    type: Literal["tombstone"] = "tombstone"
+
+
+@dataclass
+class ErrorEvent:
+    """An error occurred during streaming."""
+
+    error: str
+    is_retryable: bool
+    type: Literal["error"] = "error"
+
+
+# -- AgentLoop-originated events (consumed by Renderer) ------------------------
+
+
+@dataclass
+class ToolResultEvent:
+    """A tool has finished executing -- result available."""
+
+    tool_use_id: str
+    tool_name: str
+    result: str
+    is_error: bool = False
+    type: Literal["tool_result"] = "tool_result"
+
+
+@dataclass
+class PermissionRequestEvent:
+    """Tool execution requires user permission."""
+
+    tool_name: str
+    tool_input: dict[str, Any]
+    tool_use_id: str
+    response_future: asyncio.Future[bool] | None = field(default=None)
+    type: Literal["permission_request"] = "permission_request"
+
+
+@dataclass
+class CompactionEvent:
+    """Context auto-compaction occurred."""
+
+    original_tokens: int = 0
+    compacted_tokens: int = 0
+    type: Literal["compaction"] = "compaction"
+
+
+@dataclass
+class TaskNotificationEvent:
+    """A background agent task has completed/failed/stopped."""
+
+    task_id: str
+    description: str
+    status: str  # "completed" | "failed" | "stopped"
+    result: str | None = None
+    error: str | None = None
+    type: Literal["task_notification"] = "task_notification"
+
+
+@dataclass
+class SubAgentToolEvent:
+    """A sub-agent's internal tool activity — forwarded to parent Renderer."""
+
+    parent_tool_use_id: str  # The parent AgentTool's tool_use_id
+    child_tool_name: str  # Tool name the sub-agent called
+    child_tool_input: dict  # Tool input params
+    is_done: bool = False  # Whether this child tool finished
+    is_error: bool = False
+    type: Literal["subagent_tool"] = "subagent_tool"
+
+
+@dataclass
+class StackProgressEvent:
+    """Real-time progress from a stack lifecycle operation."""
+
+    stack_id: str
+    stack_name: str
+    status: str
+    progress_percentage: float
+    resources: list[dict[str, Any]]
+    elapsed_seconds: int
+    type: Literal["stack_progress"] = "stack_progress"
+
+
+@dataclass
+class StackInstancesProgressEvent:
+    """Real-time progress from a StackGroup instances operation."""
+
+    stack_group_name: str
+    operation_id: str
+    status: str
+    progress_percentage: int
+    instances: list[dict[str, Any]]
+    elapsed_seconds: int
+    type: Literal["stack_instances_progress"] = "stack_instances_progress"
+
+
+@dataclass
+class PlanStep:
+    """A single step in an agent plan."""
+
+    content: str
+    status: Literal["pending", "in_progress", "completed"] = "pending"
+    priority: Literal["high", "medium", "low"] = "medium"
+
+
+@dataclass
+class PlanEvent:
+    """Agent plan creation or update."""
+
+    steps: list[PlanStep]
+    type: Literal["plan"] = "plan"
+
+
+StreamEvent = Union[
+    MessageStartEvent,
+    TextDeltaEvent,
+    ThinkingDeltaEvent,
+    ToolUseStartEvent,
+    ToolInputDeltaEvent,
+    ToolUseEndEvent,
+    MessageEndEvent,
+    TombstoneEvent,
+    ErrorEvent,
+    ToolResultEvent,
+    PermissionRequestEvent,
+    CompactionEvent,
+    TaskNotificationEvent,
+    SubAgentToolEvent,
+    StackProgressEvent,
+    StackInstancesProgressEvent,
+    PlanEvent,
+]

iac_code/ui/__init__.py

@@ -0,0 +1,5 @@
+"""Rich-based inline UI"""
+
+from iac_code.ui.repl import InlineREPL
+
+__all__ = ["InlineREPL"]

iac_code/ui/banner.py

@@ -0,0 +1,110 @@
+"""Welcome banner rendering."""
+
+from __future__ import annotations
+
+import getpass
+from pathlib import Path
+
+from rich.align import Align
+from rich.console import Group
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from iac_code.i18n import _
+
+# Cloud logo (same as components/logo.py)
+LOGO_LINES = [
+    "      ▄▄███▄▄      ",
+    "   ▄██████████▄▄   ",
+    " ▄█▀████████████▄  ",
+    "████████████████████",
+    " ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ ",
+]
+
+ACCENT = "bright_cyan"
+
+
+def _get_provider_display() -> str:
+    """Get the active provider display name from settings, translated."""
+    try:
+        from iac_code.config import get_active_provider_key, get_provider_config
+
+        key = get_active_provider_key()
+        if not key:
+            return ""
+        name = get_provider_config(key).get("name", "")
+        provider_display_names = {
+            "DashScope": _("DashScope"),
+            "DashScope Token Plan": _("DashScope Token Plan"),
+            "OpenAI": _("OpenAI"),
+            "Anthropic": _("Anthropic"),
+            "DeepSeek": _("DeepSeek"),
+            "OpenAPI Compatible": _("OpenAPI Compatible"),
+        }
+        return provider_display_names.get(name, name)
+    except Exception:
+        return ""
+
+
+def render_welcome_banner(model: str, cwd: str, session_id: str | None = None) -> Panel:
+    """Produce a Rich Panel for the welcome banner."""
+    # Username
+    try:
+        username = getpass.getuser()
+        username = username[0].upper() + username[1:] if username else "User"
+    except Exception:
+        username = "User"
+
+    # Logo
+    logo = Text()
+    for i, line in enumerate(LOGO_LINES):
+        if i > 0:
+            logo.append("\n")
+        logo.append(f"   {line}", style="bright_cyan")
+
+    # Description (centered vertically beside the logo)
+    desc_text = Text(_("Your AI-powered Infrastructure as Code assistant"), style="italic white")
+
+    # Use a table for side-by-side layout with vertical centering
+    logo_table = Table(show_header=False, show_edge=False, box=None, padding=0, expand=True)
+    logo_table.add_column(ratio=1)
+    logo_table.add_column(ratio=2)
+    logo_table.add_row(logo, Align(desc_text, align="center", vertical="middle"))
+
+    # Shorten cwd
+    cwd_path = Path(cwd).resolve()
+    try:
+        cwd_display = "~/" + str(cwd_path.relative_to(Path.home()))
+    except ValueError:
+        cwd_display = str(cwd_path)
+
+    # Provider / model display
+    provider_name = _get_provider_display()
+    if provider_name and model:
+        model_display = f"{provider_name} / {model}"
+    else:
+        model_display = model
+
+    items = [
+        Text(),
+        Text(f"  {_('Welcome back')} {username}!", style="bold"),
+        Text(),
+        logo_table,
+        Text(),
+        Text(f"  {model_display}", style="dim") if model_display else Text(),
+        Text(f"  {cwd_display}", style="dim"),
+        Text(f"  {_('Session')}: {session_id}", style="dim") if session_id else Text(),
+    ]
+
+    from iac_code.utils.log import is_debug_enabled
+
+    if is_debug_enabled():
+        from iac_code.config import get_config_dir
+
+        log_path = get_config_dir() / "logs" / "latest.log"
+        items.append(Text())
+        items.append(Text(f"  {_('Debug mode')}", style="bold yellow"))
+        items.append(Text(f"  {_('Log file')}: {log_path}", style="dim yellow"))
+
+    return Panel(Group(*items), border_style=ACCENT, expand=True)

iac_code/ui/components/dialog.py

@@ -0,0 +1,142 @@
+"""Modal dialog container component."""
+
+from __future__ import annotations
+
+from typing import Callable
+
+from rich.console import Console, RenderableType
+from rich.panel import Panel
+from rich.text import Text
+
+from iac_code.ui.keybindings.manager import KeyBinding, KeybindingManager
+
+
+class Dialog:
+    """A modal dialog container that renders content inside a framed panel.
+
+    Two usage modes:
+
+    1. :meth:`show` — render frame + body once (e.g. inside an existing loop).
+    2. :meth:`run` — manage the full event loop, including in-place rendering
+       and dialog-context keybindings. Renders in the main buffer with
+       erase-and-redraw between frames so nothing leaks into scrollback.
+    """
+
+    def __init__(
+        self,
+        title: str,
+        keybinding_manager: KeybindingManager,
+        on_cancel: Callable[[], None],
+        subtitle: str | None = None,
+        footer_hints: list[tuple[str, str]] | None = None,
+        border_style: str = "blue",
+    ) -> None:
+        self._title = title
+        self._km = keybinding_manager
+        self._on_cancel = on_cancel
+        self._subtitle = subtitle
+        self._footer_hints = footer_hints or []
+        self._border_style = border_style
+        self._closed = False
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def show(self, body: RenderableType) -> None:
+        """Render the dialog frame and body to the console once."""
+        Console().print(self._build_frame(body))
+
+    def run(
+        self,
+        body_builder: Callable[[], RenderableType],
+        key_handler: Callable | None = None,
+    ) -> None:
+        """Run an in-place event loop until the dialog is closed.
+
+        Flow:
+
+        1. Push "dialog" context to KeybindingManager.
+        2. Register Escape and Ctrl+C as cancel.
+        3. Loop: ``body_builder() → render → read_key → key_handler → km.resolve``
+        4. On exit: erase the rendered frame, pop context, unregister.
+        """
+        from iac_code.ui.core.in_place_render import InPlaceRenderer
+        from iac_code.ui.core.raw_input import RawInputCapture
+
+        renderer = InPlaceRenderer(Console())
+        self._km.push_context("dialog")
+
+        def _cancel() -> bool:
+            self._on_cancel()
+            self.close()
+            return True
+
+        unregister_escape = self._km.register(
+            KeyBinding(key="escape", action="dialog_cancel", context="dialog", handler=_cancel)
+        )
+        unregister_ctrl_c = self._km.register(
+            KeyBinding(key="ctrl+c", action="dialog_cancel", context="dialog", handler=_cancel)
+        )
+
+        try:
+            with RawInputCapture() as cap:
+                while not self._closed:
+                    body = body_builder()
+                    renderer.render(self._build_frame(body))
+                    key_event = cap.read_key(timeout=0.1)
+                    if key_event is None:
+                        continue
+                    consumed = False
+                    if key_handler is not None:
+                        consumed = key_handler(key_event)
+                    if not consumed:
+                        self._km.resolve(key_event)
+        finally:
+            renderer.clear()
+            unregister_escape()
+            unregister_ctrl_c()
+            self._km.pop_context("dialog")
+
+    def close(self) -> None:
+        """Mark the dialog closed; the next loop iteration exits."""
+        self._closed = True
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _build_panel_body(self, body: RenderableType) -> RenderableType:
+        """Assemble subtitle + body + footer into a single renderable."""
+        from rich.console import Group
+
+        parts: list[RenderableType] = []
+
+        if self._subtitle:
+            parts.append(Text(self._subtitle, style="dim"))
+
+        parts.append(body)
+
+        if self._footer_hints:
+            footer = self._build_footer()
+            parts.append(footer)
+
+        if len(parts) == 1:
+            return parts[0]
+        return Group(*parts)
+
+    def _build_frame(self, body: RenderableType) -> Panel:
+        """Build the full Panel with title, body, and footer."""
+        panel_body = self._build_panel_body(body)
+        title_text = Text(self._title, style="bold")
+        return Panel(panel_body, title=title_text, border_style=self._border_style)
+
+    def _build_footer(self) -> Text:
+        """Build footer hints line."""
+        text = Text()
+        for i, (key_display, action) in enumerate(self._footer_hints):
+            if i > 0:
+                text.append("  ")
+            text.append(key_display, style="bold cyan")
+            text.append(f" {action}", style="dim")
+        return text

iac_code/ui/components/divider.py

@@ -0,0 +1,20 @@
+"""Divider component wrapping Rich Rule."""
+
+from __future__ import annotations
+
+from rich.rule import Rule
+
+
+class Divider:
+    """A horizontal divider line, optionally with centered text.
+
+    Wraps :class:`rich.rule.Rule`.
+    """
+
+    def __init__(self, text: str = "", style: str = "dim") -> None:
+        self.text = text
+        self.style = style
+
+    def render(self) -> Rule:
+        """Return a Rich Rule renderable."""
+        return Rule(title=self.text, style=self.style)