functualize-inline 0.1.0__py3-none-any.whl

functualize_inline/__init__.py

@@ -0,0 +1,5 @@
+"""Functualize Inline Plugin - Textual inline interactivity for terminal prompts."""
+
+from functualize_inline.plugin import InlinePlugin
+
+__all__ = ["InlinePlugin"]

functualize_inline/apps.py

@@ -0,0 +1,74 @@
+"""Textual inline applications for prompt rendering.
+
+Uses Textual's `inline=True` mode to render widgets inline within the terminal
+without taking over the full screen. Each prompt spawns a short-lived inline app
+that returns the user's response.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from textual import on
+from textual.app import App, ComposeResult
+
+from functualize_inline.widgets import (
+    PromptResult,
+)
+
+
+class InlinePromptApp(App[tuple[Any, str]]):
+    """A short-lived Textual app that renders a prompt widget inline.
+
+    Returns a tuple of (value, source) when the user interacts with the widget.
+    The app runs in inline mode and exits once a PromptResult message is received.
+    """
+
+    CSS = """
+    Screen {
+        layout: vertical;
+        overflow-y: auto;
+    }
+    """
+
+    BINDINGS = [
+        ("ctrl+c", "force_cancel", "Cancel"),
+    ]
+
+    def __init__(
+        self,
+        widget_class: type,
+        widget_kwargs: dict[str, Any],
+        timeout: float | None = None,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(inline=True, **kwargs)
+        self._widget_class = widget_class
+        self._widget_kwargs = widget_kwargs
+        self._timeout = timeout
+        self._timeout_timer: Any = None
+
+    def compose(self) -> ComposeResult:
+        yield self._widget_class(**self._widget_kwargs)
+
+    def on_mount(self) -> None:
+        """Start timeout timer if configured."""
+        if self._timeout is not None and self._timeout > 0:
+            self._timeout_timer = self.set_timer(self._timeout, self._on_timeout)
+
+    def _on_timeout(self) -> None:
+        """Auto-dismiss on timeout."""
+        self.exit((None, "timeout"))
+
+    @on(PromptResult)
+    def _on_prompt_result(self, message: PromptResult) -> None:
+        """Handle result from the prompt widget."""
+        if self._timeout_timer is not None:
+            self._timeout_timer.stop()
+        self.exit((message.value, message.source))
+
+    def action_force_cancel(self) -> None:
+        """Handle Ctrl+C."""
+        if self._timeout_timer is not None:
+            self._timeout_timer.stop()
+        self.exit((None, "cancelled"))

functualize_inline/plugin.py

@@ -0,0 +1,335 @@
+"""Functualize Inline Plugin — a PromptCollector using Textual inline mode.
+
+Implements ``collect`` to render rich inline terminal widgets for each
+PromptIntent. Falls back to plain CLI input() when Textual inline mode is
+unavailable (non-TTY, import failure, or lacking terminal support).
+"""
+
+from __future__ import annotations
+
+import logging
+import sys
+from typing import Any
+
+from functualize._types.interactivity import (
+    PromptIntent,
+    PromptRequest,
+    PromptResponse,
+)
+
+__all__ = ["InlinePlugin"]
+
+logger = logging.getLogger(__name__)
+
+
+def _is_inline_available() -> bool:
+    """Check if Textual inline mode is available.
+
+    Returns False if:
+    - stdin/stdout is not a TTY
+    - Textual cannot be imported
+    - Terminal lacks inline support
+    """
+    try:
+        if not sys.stdin.isatty() or not sys.stdout.isatty():
+            return False
+        # Verify Textual can be imported and inline mode is supported
+        from textual.app import App  # noqa: F401
+
+        return True
+    except (ImportError, AttributeError, OSError):
+        return False
+
+
+class InlinePlugin:
+    """Textual inline PromptCollector for functualize prompts.
+
+    Dispatches PromptRequest objects to appropriate Textual inline widgets
+    based on PromptIntent. Falls back to plain CLI when Textual inline is
+    unavailable.
+    """
+
+    name: str = "inline"
+    version: str = "0.1.0"
+    description: str = "Textual inline terminal prompts"
+
+    def __call__(self, app: Any) -> None:
+        """Register this plugin as a PromptCollector with the application."""
+        try:
+            app.register_surface(self)
+            logger.debug("InlinePlugin registered as PromptCollector")
+        except Exception as e:
+            logger.warning("InlinePlugin: Failed to register: %s", e)
+
+    # ─── PromptCollector Protocol ────────────────────────────────────
+
+    def collect(self, request: PromptRequest) -> PromptResponse:
+        """Collect user input for the given prompt request.
+
+        Dispatches to Textual inline widgets when available, otherwise
+        falls back to plain CLI input().
+
+        Args:
+            request: The structured prompt request with intent, choices, etc.
+
+        Returns:
+            PromptResponse with the user's value and source metadata.
+        """
+        if _is_inline_available():
+            return self._prompt_inline(request)
+        return self._prompt_cli_fallback(request)
+
+    # ─── Textual Inline Path ─────────────────────────────────────────
+
+    def _prompt_inline(self, request: PromptRequest) -> PromptResponse:
+        """Render a Textual inline widget based on prompt intent."""
+        from functualize_inline.apps import InlinePromptApp
+        from functualize_inline.widgets import (
+            AcknowledgeWidget,
+            ConfirmDestructiveWidget,
+            ConfirmNeutralWidget,
+            MultiSelectWidget,
+            SecretInputWidget,
+            SelectWidget,
+            TextInputWidget,
+        )
+
+        intent = request.intent
+        widget_class: type
+        widget_kwargs: dict[str, Any] = {}
+
+        if intent == PromptIntent.CONFIRM_DESTRUCTIVE:
+            widget_class = ConfirmDestructiveWidget
+            widget_kwargs = {
+                "question": request.question,
+                "context_message": request.context_message,
+            }
+        elif intent in (PromptIntent.CONFIRM_NEUTRAL, PromptIntent.CONFIRM_PROCEED):
+            widget_class = ConfirmNeutralWidget
+            widget_kwargs = {
+                "question": request.question,
+                "default": request.default,
+                "context_message": request.context_message,
+            }
+        elif intent == PromptIntent.SELECT:
+            widget_class = SelectWidget
+            widget_kwargs = {
+                "question": request.question,
+                "choices": request.choices or [],
+                "context_message": request.context_message,
+            }
+        elif intent == PromptIntent.MULTI_SELECT:
+            widget_class = MultiSelectWidget
+            widget_kwargs = {
+                "question": request.question,
+                "choices": request.choices or [],
+                "context_message": request.context_message,
+            }
+        elif intent == PromptIntent.SECRET_INPUT:
+            widget_class = SecretInputWidget
+            widget_kwargs = {
+                "question": request.question,
+                "placeholder": request.placeholder,
+                "context_message": request.context_message,
+            }
+        elif intent == PromptIntent.ACKNOWLEDGE:
+            widget_class = AcknowledgeWidget
+            widget_kwargs = {
+                "question": request.question,
+                "context_message": request.context_message,
+            }
+        else:
+            # TEXT_INPUT or any unknown intent
+            widget_class = TextInputWidget
+            widget_kwargs = {
+                "question": request.question,
+                "placeholder": request.placeholder,
+                "default": request.default,
+                "context_message": request.context_message,
+            }
+
+        try:
+            app = InlinePromptApp(
+                widget_class=widget_class,
+                widget_kwargs=widget_kwargs,
+                timeout=request.timeout,
+            )
+            result = app.run()
+
+            if result is None:
+                # App exited without returning a result (shouldn't happen normally)
+                return PromptResponse(value=None, source="cancelled")
+
+            value, source = result
+
+            # For timeout, use the default value
+            if source == "timeout":
+                return PromptResponse(value=request.default, source="timeout")
+
+            return PromptResponse(value=value, source=source)
+
+        except Exception as e:
+            logger.warning(
+                "InlinePlugin: Textual inline failed (%s), falling back to CLI", e
+            )
+            return self._prompt_cli_fallback(request)
+
+    # ─── Plain CLI Fallback ──────────────────────────────────────────
+
+    def _prompt_cli_fallback(self, request: PromptRequest) -> PromptResponse:
+        """Plain CLI fallback using standard input/print.
+
+        Used when Textual inline mode is unavailable.
+        """
+        intent = request.intent
+
+        try:
+            if intent == PromptIntent.CONFIRM_DESTRUCTIVE:
+                return self._cli_confirm_destructive(request)
+            elif intent in (PromptIntent.CONFIRM_NEUTRAL, PromptIntent.CONFIRM_PROCEED):
+                return self._cli_confirm_neutral(request)
+            elif intent == PromptIntent.SELECT:
+                return self._cli_select(request)
+            elif intent == PromptIntent.MULTI_SELECT:
+                return self._cli_multi_select(request)
+            elif intent == PromptIntent.SECRET_INPUT:
+                return self._cli_secret_input(request)
+            elif intent == PromptIntent.ACKNOWLEDGE:
+                return self._cli_acknowledge(request)
+            else:
+                return self._cli_text_input(request)
+        except (KeyboardInterrupt, EOFError):
+            return PromptResponse(value=None, source="cancelled")
+
+    def _cli_confirm_destructive(self, request: PromptRequest) -> PromptResponse:
+        """CLI fallback for CONFIRM_DESTRUCTIVE: requires typing 'yes'."""
+        if request.context_message:
+            print(f"  {request.context_message}")
+        prompt_text = f"⚠ {request.question} (type 'yes' to confirm): "
+        try:
+            response = input(prompt_text)
+        except (KeyboardInterrupt, EOFError):
+            return PromptResponse(value=None, source="cancelled")
+        confirmed = response.strip().lower() == "yes"
+        return PromptResponse(value=confirmed, source="user")
+
+    def _cli_confirm_neutral(self, request: PromptRequest) -> PromptResponse:
+        """CLI fallback for CONFIRM_NEUTRAL: Y/n prompt."""
+        if request.context_message:
+            print(f"  {request.context_message}")
+        default_hint = "[Y/n]" if request.default is True else "[y/N]"
+        prompt_text = f"{request.question} {default_hint}: "
+        try:
+            response = input(prompt_text)
+        except (KeyboardInterrupt, EOFError):
+            return PromptResponse(value=None, source="cancelled")
+        val = response.strip().lower()
+        if val == "":
+            result = request.default if request.default is not None else True
+        elif val in ("y", "yes"):
+            result = True
+        else:
+            result = False
+        return PromptResponse(value=result, source="user")
+
+    def _cli_select(self, request: PromptRequest) -> PromptResponse:
+        """CLI fallback for SELECT: numbered list."""
+        if request.context_message:
+            print(f"  {request.context_message}")
+        print(f"{request.question}")
+        choices = request.choices or []
+        for i, choice in enumerate(choices, 1):
+            label = choice.label or choice.value
+            disabled = " [disabled]" if choice.disabled else ""
+            desc = f" — {choice.description}" if choice.description else ""
+            print(f"  {i}. {label}{desc}{disabled}")
+
+        prompt_text = "Select (number): "
+        try:
+            response = input(prompt_text)
+        except (KeyboardInterrupt, EOFError):
+            return PromptResponse(value=None, source="cancelled")
+
+        try:
+            idx = int(response.strip()) - 1
+            if 0 <= idx < len(choices):
+                selected = choices[idx]
+                if selected.disabled:
+                    print("  That option is disabled.")
+                    return PromptResponse(value=request.default, source="user")
+                return PromptResponse(value=selected.value, source="user")
+        except (ValueError, IndexError):
+            pass
+
+        # Invalid selection — return default if available
+        if request.default is not None:
+            return PromptResponse(value=request.default, source="default")
+        return PromptResponse(value=None, source="cancelled")
+
+    def _cli_multi_select(self, request: PromptRequest) -> PromptResponse:
+        """CLI fallback for MULTI_SELECT: numbered list with comma-separated input."""
+        if request.context_message:
+            print(f"  {request.context_message}")
+        print(f"{request.question}")
+        choices = request.choices or []
+        for i, choice in enumerate(choices, 1):
+            label = choice.label or choice.value
+            disabled = " [disabled]" if choice.disabled else ""
+            desc = f" — {choice.description}" if choice.description else ""
+            print(f"  {i}. {label}{desc}{disabled}")
+
+        prompt_text = "Select (comma-separated numbers): "
+        try:
+            response = input(prompt_text)
+        except (KeyboardInterrupt, EOFError):
+            return PromptResponse(value=None, source="cancelled")
+
+        selected: list[str] = []
+        for part in response.split(","):
+            part = part.strip()
+            try:
+                idx = int(part) - 1
+                if 0 <= idx < len(choices) and not choices[idx].disabled:
+                    selected.append(choices[idx].value)
+            except (ValueError, IndexError):
+                continue
+
+        return PromptResponse(value=selected, source="user")
+
+    def _cli_secret_input(self, request: PromptRequest) -> PromptResponse:
+        """CLI fallback for SECRET_INPUT: uses getpass for masked input."""
+        import getpass
+
+        if request.context_message:
+            print(f"  {request.context_message}")
+        prompt_text = f"{request.question}: "
+        try:
+            value = getpass.getpass(prompt_text)
+        except (KeyboardInterrupt, EOFError):
+            return PromptResponse(value=None, source="cancelled")
+        return PromptResponse(value=value, source="user")
+
+    def _cli_acknowledge(self, request: PromptRequest) -> PromptResponse:
+        """CLI fallback for ACKNOWLEDGE: press Enter to continue."""
+        if request.context_message:
+            print(f"  {request.context_message}")
+        prompt_text = f"{request.question} [Press Enter to continue]: "
+        try:
+            input(prompt_text)
+        except (KeyboardInterrupt, EOFError):
+            return PromptResponse(value=None, source="cancelled")
+        return PromptResponse(value=True, source="user")
+
+    def _cli_text_input(self, request: PromptRequest) -> PromptResponse:
+        """CLI fallback for TEXT_INPUT: plain input()."""
+        if request.context_message:
+            print(f"  {request.context_message}")
+        default_hint = f" [{request.default}]" if request.default is not None else ""
+        prompt_text = f"{request.question}{default_hint}: "
+        try:
+            value = input(prompt_text)
+        except (KeyboardInterrupt, EOFError):
+            return PromptResponse(value=None, source="cancelled")
+        if not value and request.default is not None:
+            return PromptResponse(value=request.default, source="default")
+        return PromptResponse(value=value, source="user")

functualize_inline/widgets.py

@@ -0,0 +1,437 @@
+"""Custom Textual widgets for inline prompt rendering.
+
+Each widget corresponds to a PromptIntent and handles user interaction,
+returning the result via a message posted to the parent app.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from textual import on
+from textual.binding import Binding
+from textual.message import Message
+from textual.widget import Widget
+from textual.widgets import Input, Label, OptionList, Static
+from textual.widgets.option_list import Option
+
+if TYPE_CHECKING:
+    from textual.app import ComposeResult
+
+
+class PromptResult(Message):
+    """Message posted when a widget produces a result."""
+
+    def __init__(self, value: object, source: str = "user") -> None:
+        super().__init__()
+        self.value = value
+        self.source = source
+
+
+class ConfirmDestructiveWidget(Widget):
+    """Red-bordered widget requiring the user to type 'yes' to confirm."""
+
+    BINDINGS = [
+        Binding("escape", "cancel", "Cancel", show=False),
+    ]
+
+    DEFAULT_CSS = """
+    ConfirmDestructiveWidget {
+        border: heavy red;
+        padding: 1 2;
+        height: auto;
+        width: 100%;
+    }
+    ConfirmDestructiveWidget Label {
+        margin-bottom: 1;
+    }
+    ConfirmDestructiveWidget .context-msg {
+        color: $text-muted;
+        margin-bottom: 1;
+    }
+    """
+
+    def __init__(
+        self,
+        question: str,
+        context_message: str | None = None,
+        **kwargs: object,
+    ) -> None:
+        super().__init__(**kwargs)
+        self._question = question
+        self._context_message = context_message
+
+    def compose(self) -> ComposeResult:
+        yield Label(f"[bold red]⚠ {self._question}[/]")
+        if self._context_message:
+            yield Static(self._context_message, classes="context-msg")
+        yield Label('[dim]Type "yes" to confirm, anything else to cancel[/]')
+        yield Input(placeholder="yes")
+
+    @on(Input.Submitted)
+    def _on_submit(self, event: Input.Submitted) -> None:
+        confirmed = event.value.strip().lower() == "yes"
+        self.post_message(PromptResult(value=confirmed, source="user"))
+
+    def action_cancel(self) -> None:
+        self.post_message(PromptResult(value=None, source="cancelled"))
+
+
+class ConfirmNeutralWidget(Widget):
+    """Standard Y/n confirmation widget."""
+
+    BINDINGS = [
+        Binding("escape", "cancel", "Cancel", show=False),
+        Binding("y", "confirm_yes", "Yes", show=False),
+        Binding("n", "confirm_no", "No", show=False),
+    ]
+
+    DEFAULT_CSS = """
+    ConfirmNeutralWidget {
+        border: solid $accent;
+        padding: 1 2;
+        height: auto;
+        width: 100%;
+    }
+    ConfirmNeutralWidget Label {
+        margin-bottom: 1;
+    }
+    ConfirmNeutralWidget .context-msg {
+        color: $text-muted;
+        margin-bottom: 1;
+    }
+    """
+
+    def __init__(
+        self,
+        question: str,
+        default: object = None,
+        context_message: str | None = None,
+        **kwargs: object,
+    ) -> None:
+        super().__init__(**kwargs)
+        self._question = question
+        self._default = default
+        self._context_message = context_message
+
+    def compose(self) -> ComposeResult:
+        default_hint = "[Y/n]" if self._default is True else "[y/N]"
+        yield Label(f"{self._question} {default_hint}")
+        if self._context_message:
+            yield Static(self._context_message, classes="context-msg")
+        yield Input(placeholder="y/n")
+
+    @on(Input.Submitted)
+    def _on_submit(self, event: Input.Submitted) -> None:
+        val = event.value.strip().lower()
+        if val == "":
+            result = self._default if self._default is not None else True
+        elif val in ("y", "yes"):
+            result = True
+        else:
+            result = False
+        self.post_message(PromptResult(value=result, source="user"))
+
+    def action_cancel(self) -> None:
+        self.post_message(PromptResult(value=None, source="cancelled"))
+
+    def action_confirm_yes(self) -> None:
+        self.post_message(PromptResult(value=True, source="user"))
+
+    def action_confirm_no(self) -> None:
+        self.post_message(PromptResult(value=False, source="user"))
+
+
+class SelectWidget(Widget):
+    """OptionList widget for SELECT intent with max 12 visible items."""
+
+    BINDINGS = [
+        Binding("escape", "cancel", "Cancel", show=False),
+    ]
+
+    DEFAULT_CSS = """
+    SelectWidget {
+        border: solid $accent;
+        padding: 1 2;
+        height: auto;
+        max-height: 18;
+        width: 100%;
+    }
+    SelectWidget Label {
+        margin-bottom: 1;
+    }
+    SelectWidget .context-msg {
+        color: $text-muted;
+        margin-bottom: 1;
+    }
+    SelectWidget OptionList {
+        max-height: 12;
+    }
+    """
+
+    def __init__(
+        self,
+        question: str,
+        choices: list[object],
+        context_message: str | None = None,
+        **kwargs: object,
+    ) -> None:
+        super().__init__(**kwargs)
+        self._question = question
+        self._choices = choices
+        self._context_message = context_message
+
+    def compose(self) -> ComposeResult:
+        yield Label(self._question)
+        if self._context_message:
+            yield Static(self._context_message, classes="context-msg")
+        option_list = OptionList()
+        for choice in self._choices:
+            label = choice.label or choice.value  # type: ignore[union-attr]
+            prompt = label
+            if choice.description:  # type: ignore[union-attr]
+                prompt = f"{label} — {choice.description}"  # type: ignore[union-attr]
+            option_list.add_option(
+                Option(prompt, id=choice.value, disabled=choice.disabled)  # type: ignore[union-attr]
+            )
+        yield option_list
+
+    @on(OptionList.OptionSelected)
+    def _on_selected(self, event: OptionList.OptionSelected) -> None:
+        if event.option.id is not None:
+            self.post_message(PromptResult(value=event.option.id, source="user"))
+
+    def action_cancel(self) -> None:
+        self.post_message(PromptResult(value=None, source="cancelled"))
+
+
+class MultiSelectWidget(Widget):
+    """Checkbox list for MULTI_SELECT intent."""
+
+    BINDINGS = [
+        Binding("escape", "cancel", "Cancel", show=False),
+        Binding("enter", "submit", "Submit", show=False),
+    ]
+
+    DEFAULT_CSS = """
+    MultiSelectWidget {
+        border: solid $accent;
+        padding: 1 2;
+        height: auto;
+        max-height: 20;
+        width: 100%;
+    }
+    MultiSelectWidget Label {
+        margin-bottom: 1;
+    }
+    MultiSelectWidget .context-msg {
+        color: $text-muted;
+        margin-bottom: 1;
+    }
+    MultiSelectWidget OptionList {
+        max-height: 12;
+    }
+    """
+
+    def __init__(
+        self,
+        question: str,
+        choices: list[object],
+        context_message: str | None = None,
+        **kwargs: object,
+    ) -> None:
+        super().__init__(**kwargs)
+        self._question = question
+        self._choices = choices
+        self._context_message = context_message
+        self._selected: set[str] = set()
+
+    def compose(self) -> ComposeResult:
+        yield Label(f"{self._question} [dim](Space to toggle, Enter to confirm)[/]")
+        if self._context_message:
+            yield Static(self._context_message, classes="context-msg")
+        option_list = OptionList()
+        for choice in self._choices:
+            label = choice.label or choice.value  # type: ignore[union-attr]
+            prompt = f"☐ {label}"
+            if choice.description:  # type: ignore[union-attr]
+                prompt = f"☐ {label} — {choice.description}"  # type: ignore[union-attr]
+            option_list.add_option(
+                Option(prompt, id=choice.value, disabled=choice.disabled)  # type: ignore[union-attr]
+            )
+        yield option_list
+
+    @on(OptionList.OptionSelected)
+    def _on_toggle(self, event: OptionList.OptionSelected) -> None:
+        """Toggle selection on the chosen option."""
+        if event.option.id is None:
+            return
+        opt_id = event.option.id
+        if opt_id in self._selected:
+            self._selected.discard(opt_id)
+        else:
+            self._selected.add(opt_id)
+        # Update display to reflect selection state
+        option_list = self.query_one(OptionList)
+        idx = event.option_index
+        choice = self._choices[idx]
+        label = choice.label or choice.value  # type: ignore[union-attr]
+        check = "☑" if opt_id in self._selected else "☐"
+        desc = f" — {choice.description}" if choice.description else ""  # type: ignore[union-attr]
+        option_list.replace_option_prompt(idx, f"{check} {label}{desc}")
+
+    def action_submit(self) -> None:
+        self.post_message(PromptResult(value=list(self._selected), source="user"))
+
+    def action_cancel(self) -> None:
+        self.post_message(PromptResult(value=None, source="cancelled"))
+
+
+class TextInputWidget(Widget):
+    """Text input widget for TEXT_INPUT intent."""
+
+    BINDINGS = [
+        Binding("escape", "cancel", "Cancel", show=False),
+    ]
+
+    DEFAULT_CSS = """
+    TextInputWidget {
+        border: solid $accent;
+        padding: 1 2;
+        height: auto;
+        width: 100%;
+    }
+    TextInputWidget Label {
+        margin-bottom: 1;
+    }
+    TextInputWidget .context-msg {
+        color: $text-muted;
+        margin-bottom: 1;
+    }
+    """
+
+    def __init__(
+        self,
+        question: str,
+        placeholder: str | None = None,
+        default: object = None,
+        context_message: str | None = None,
+        **kwargs: object,
+    ) -> None:
+        super().__init__(**kwargs)
+        self._question = question
+        self._placeholder = placeholder or ""
+        self._default = default
+        self._context_message = context_message
+
+    def compose(self) -> ComposeResult:
+        yield Label(self._question)
+        if self._context_message:
+            yield Static(self._context_message, classes="context-msg")
+        default_str = str(self._default) if self._default is not None else ""
+        yield Input(placeholder=self._placeholder, value=default_str)
+
+    @on(Input.Submitted)
+    def _on_submit(self, event: Input.Submitted) -> None:
+        value = event.value
+        if not value and self._default is not None:
+            value = str(self._default)
+        self.post_message(PromptResult(value=value, source="user"))
+
+    def action_cancel(self) -> None:
+        self.post_message(PromptResult(value=None, source="cancelled"))
+
+
+class SecretInputWidget(Widget):
+    """Masked input widget for SECRET_INPUT intent."""
+
+    BINDINGS = [
+        Binding("escape", "cancel", "Cancel", show=False),
+    ]
+
+    DEFAULT_CSS = """
+    SecretInputWidget {
+        border: solid $accent;
+        padding: 1 2;
+        height: auto;
+        width: 100%;
+    }
+    SecretInputWidget Label {
+        margin-bottom: 1;
+    }
+    SecretInputWidget .context-msg {
+        color: $text-muted;
+        margin-bottom: 1;
+    }
+    """
+
+    def __init__(
+        self,
+        question: str,
+        placeholder: str | None = None,
+        context_message: str | None = None,
+        **kwargs: object,
+    ) -> None:
+        super().__init__(**kwargs)
+        self._question = question
+        self._placeholder = placeholder or ""
+        self._context_message = context_message
+
+    def compose(self) -> ComposeResult:
+        yield Label(self._question)
+        if self._context_message:
+            yield Static(self._context_message, classes="context-msg")
+        yield Input(placeholder=self._placeholder, password=True)
+
+    @on(Input.Submitted)
+    def _on_submit(self, event: Input.Submitted) -> None:
+        self.post_message(PromptResult(value=event.value, source="user"))
+
+    def action_cancel(self) -> None:
+        self.post_message(PromptResult(value=None, source="cancelled"))
+
+
+class AcknowledgeWidget(Widget):
+    """Any-key dismiss widget for ACKNOWLEDGE intent."""
+
+    BINDINGS = [
+        Binding("escape", "dismiss", "Dismiss", show=False),
+    ]
+
+    DEFAULT_CSS = """
+    AcknowledgeWidget {
+        border: solid $success;
+        padding: 1 2;
+        height: auto;
+        width: 100%;
+    }
+    AcknowledgeWidget Label {
+        margin-bottom: 1;
+    }
+    AcknowledgeWidget .context-msg {
+        color: $text-muted;
+        margin-bottom: 1;
+    }
+    """
+
+    def __init__(
+        self,
+        question: str,
+        context_message: str | None = None,
+        **kwargs: object,
+    ) -> None:
+        super().__init__(**kwargs)
+        self._question = question
+        self._context_message = context_message
+
+    def compose(self) -> ComposeResult:
+        yield Label(self._question)
+        if self._context_message:
+            yield Static(self._context_message, classes="context-msg")
+        yield Label("[dim]Press any key to continue...[/]")
+
+    def on_key(self, event: object) -> None:
+        self.post_message(PromptResult(value=True, source="user"))
+
+    def action_dismiss(self) -> None:
+        self.post_message(PromptResult(value=True, source="user"))

functualize_inline-0.1.0.dist-info/METADATA

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: functualize-inline
+Version: 0.1.0
+Summary: Textual inline interactivity plugin for functualize prompts
+Author-email: Mohammad Hakim Adiprasetya <viltohmyst@gmail.com>
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: functualize<1.0.0,>=0.1.0
+Requires-Dist: textual>=0.40.0
+Provides-Extra: dev
+Requires-Dist: pytest-cov>=4.1.0; extra == 'dev'
+Requires-Dist: pytest>=7.4.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# functualize-inline
+
+> **Status: Published** — Independently installable from PyPI.
+
+Textual-based inline interactivity provider for the functualize framework. This plugin renders rich terminal widgets (confirmations, selections, text inputs, progress bars) inline within the terminal using [Textual's](https://textual.textualize.io/) inline mode — without taking over the full screen. When Textual is unavailable (non-TTY, CI environments), it gracefully falls back to plain CLI `input()` prompts.
+
+## Installation
+
+```bash
+pip install functualize-inline
+```
+
+## Quick Start
+
+```python
+from functualize.plugin import PromptIntent, PromptRequest
+from functualize_inline import InlinePlugin
+
+plugin = InlinePlugin()
+
+request = PromptRequest(
+    intent=PromptIntent.CONFIRM_NEUTRAL,
+    question="Deploy to staging?",
+    default=True,
+)
+response = plugin.collect(request)
+print(f"User answered: {response.value} (source: {response.source})")
+```
+
+## Features
+
+- **Rich inline widgets** — Confirmation dialogs, single/multi-select lists, text inputs, secret inputs, and acknowledgment prompts rendered with Textual styling
+- **Automatic CLI fallback** — Detects non-TTY environments and falls back to plain `input()` prompts so jobs run unattended in CI
+- **Structured output rendering** — Implements `OutputRenderer` protocol with `render_log`, `render_phase`, and `render_progress` for formatted terminal output with icons and progress bars
+- **Timeout support** — Prompts can auto-dismiss after a configurable timeout, returning the default value
+- **Entry-point auto-discovery** — Install the package and it registers itself as an interactivity provider via the `functualize.interactivity_providers` entry point
+
+## API Reference
+
+Public classes and functions exported by this plugin:
+
+### `functualize_inline` (top-level)
+
+- `InlinePlugin` — Main plugin class implementing `InputProvider` and `OutputRenderer` protocols. Entry point for prompt collection and terminal output rendering.
+
+### `functualize_inline.apps`
+
+- `InlinePromptApp` — A short-lived Textual `App` (inline mode) that mounts a prompt widget and returns the user's response as a `(value, source)` tuple.
+
+### `functualize_inline.widgets`
+
+- `PromptResult` — Textual `Message` posted by widgets when the user provides a response. Carries `.value` and `.source` attributes.
+- `ConfirmDestructiveWidget` — Red-bordered widget requiring the user to type "yes" to confirm dangerous actions.
+- `ConfirmNeutralWidget` — Standard Y/n confirmation widget with keyboard shortcuts.
+- `SelectWidget` — Single-select `OptionList` widget (max 12 visible items).
+- `MultiSelectWidget` — Checkbox-style multi-select widget with toggle and submit.
+- `TextInputWidget` — Free-text input with optional placeholder and default value.
+- `SecretInputWidget` — Masked password input widget.
+- `AcknowledgeWidget` — Press-any-key dismiss widget for informational prompts.
+
+## Development
+
+Run plugin tests:
+
+```bash
+uv run pytest plugins/functualize-inline/tests/ -v
+```
+
+Run linting and formatting:
+
+```bash
+uv run ruff check plugins/functualize-inline/
+uv run ruff format plugins/functualize-inline/
+```

functualize_inline-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+functualize_inline/__init__.py,sha256=EPrl-Tphos3YAb157RKNK3YGoi-WQ46FeZuQUUpdAyE,165
+functualize_inline/apps.py,sha256=YKLoR_zO1-j1P48OBqKXL5drwZzP0bBs9_05mNmP1Zs,2177
+functualize_inline/plugin.py,sha256=y08i93tyDWBnc4OeeQgThgq7PyrZKzxcZBVRYJV2MJs,13418
+functualize_inline/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+functualize_inline/widgets.py,sha256=8IS7lJjeJ-AF08lpDYpMi0j2s9yYUTWShlK554fTuls,13099
+functualize_inline-0.1.0.dist-info/METADATA,sha256=TOxFEmeH1cw9xyQRHtmB8CxsvgmUyJqie-I_qjC9sTI,3932
+functualize_inline-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+functualize_inline-0.1.0.dist-info/entry_points.txt,sha256=GmkurdMYBiBTjp1xRCsuZ_kMoEgydhjPuYp2XbAosiE,79
+functualize_inline-0.1.0.dist-info/RECORD,,

functualize_inline-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

functualize_inline-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[functualize.interactivity_providers]
+inline = functualize_inline:InlinePlugin