titan-cli 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

titan_cli/ui/tui/widgets/multiline_input.py

@@ -0,0 +1,32 @@
+"""
+MultilineInput Widget
+
+Custom TextArea that handles Enter for submission and Shift+Enter for new lines.
+"""
+
+from textual.widget import Widget
+from textual.widgets import TextArea
+from textual.message import Message
+
+
+class MultilineInput(TextArea):
+    """Custom TextArea that handles Ctrl+Enter for submission and Enter for new lines."""
+
+    class Submitted(Message):
+        """Message sent when the input is submitted."""
+        def __init__(self, sender: Widget, value: str):
+            super().__init__()
+            self.sender = sender
+            self.value = value
+
+    def _on_key(self, event) -> None:
+        """Intercept key events at low level before TextArea processes them."""
+        # Use Ctrl+D for submit (standard in many CLI tools)
+        if event.key == "ctrl+d":
+            self.post_message(self.Submitted(self, self.text))
+            event.prevent_default()
+            event.stop()
+            return
+
+        # Let TextArea handle everything else (Enter creates new lines)
+        super()._on_key(event)

titan_cli/ui/tui/widgets/prompt_choice.py

@@ -0,0 +1,138 @@
+"""
+PromptChoice Widget
+
+Widget for selecting a single option from multiple choices using buttons.
+"""
+
+from typing import Callable, List, Any
+from dataclasses import dataclass
+from textual.widget import Widget
+from textual.containers import Horizontal
+from .text import BoldText, DimText
+from .button import Button
+
+
+@dataclass
+class ChoiceOption:
+    """
+    Option for choice selection.
+
+    Attributes:
+        value: The value to return when selected (can be any type)
+        label: The text to display on the button
+        variant: Button variant (default, primary, success, warning, error)
+    """
+    value: Any
+    label: str
+    variant: str = "default"
+
+
+class PromptChoice(Widget):
+    """
+    Widget for selecting a single option from multiple choices.
+
+    Displays a question and horizontal buttons for each option.
+    User clicks a button to select that option.
+
+    Example:
+        options = [
+            ChoiceOption(value="use", label="Use as-is", variant="primary"),
+            ChoiceOption(value="edit", label="Edit", variant="default"),
+            ChoiceOption(value="reject", label="Reject", variant="error"),
+        ]
+
+        choice_widget = PromptChoice(
+            question="What would you like to do?",
+            options=options,
+            on_select=lambda value: print(f"Selected: {value}")
+        )
+    """
+
+    # Allow this widget to receive focus
+    can_focus = True
+    can_focus_children = True
+
+    DEFAULT_CSS = """
+    PromptChoice {
+        width: 100%;
+        height: auto;
+        padding: 1;
+        margin: 1 0;
+        background: $surface-lighten-1;
+        border: round $accent;
+    }
+
+    PromptChoice > BoldText,
+    PromptChoice > DimText {
+        width: 100%;
+        height: auto;
+        margin-bottom: 1;
+    }
+
+    PromptChoice Horizontal {
+        width: 100%;
+        height: auto;
+        align: center middle;
+    }
+
+    PromptChoice Button {
+        margin: 0 1;
+    }
+    """
+
+    def __init__(
+        self,
+        question: str,
+        options: List[ChoiceOption],
+        on_select: Callable[[Any], None],
+        **kwargs
+    ):
+        """
+        Initialize PromptChoice.
+
+        Args:
+            question: Question to display above the buttons
+            options: List of ChoiceOption instances
+            on_select: Callback that receives the selected value
+        """
+        super().__init__(**kwargs)
+        self.question = question
+        self.options = options
+        self.on_select_callback = on_select
+
+    def compose(self):
+        # Question text
+        yield BoldText(self.question)
+
+        # Instructions
+        yield DimText("Select an option:")
+
+        # Buttons in horizontal layout
+        with Horizontal():
+            for i, option in enumerate(self.options):
+                button = Button(
+                    option.label,
+                    variant=option.variant,
+                    id=f"choice-btn-{i}"
+                )
+                button.choice_value = option.value  # Store value on button
+                yield button
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        """Handle button press - call callback with selected value."""
+        if hasattr(event.button, 'choice_value'):
+            self.on_select_callback(event.button.choice_value)
+            event.stop()
+
+    def on_mount(self):
+        """Focus first button when mounted."""
+        self.call_after_refresh(self._focus_first_button)
+
+    def _focus_first_button(self):
+        """Focus the first button."""
+        try:
+            first_button = self.query_one("#choice-btn-0", Button)
+            self.app.set_focus(first_button)
+            self.scroll_visible(animate=False)
+        except Exception:
+            pass

titan_cli/ui/tui/widgets/prompt_input.py

@@ -0,0 +1,74 @@
+"""
+PromptInput Widget
+
+Widget wrapper for Input that handles submission events.
+"""
+
+from typing import Callable
+from textual.widget import Widget
+from textual.widgets import Input, Static
+
+
+class PromptInput(Widget):
+    """Widget wrapper for Input that handles submission events."""
+
+    # Allow this widget and its children to receive focus
+    can_focus = True
+    can_focus_children = True
+
+    DEFAULT_CSS = """
+    PromptInput {
+        width: 100%;
+        height: auto;
+        padding: 1;
+        margin: 1 0;
+        background: $surface-lighten-1;
+        border: round $accent;
+    }
+
+    PromptInput > Static {
+        width: 100%;
+        height: auto;
+        margin-bottom: 1;
+    }
+
+    PromptInput > Input {
+        width: 100%;
+    }
+    """
+
+    def __init__(self, question: str, default: str, placeholder: str, on_submit: Callable[[str], None], **kwargs):
+        super().__init__(**kwargs)
+        self.question = question
+        self.default = default
+        self.placeholder = placeholder
+        self.on_submit_callback = on_submit
+
+    def compose(self):
+        yield Static(f"[bold cyan]{self.question}[/bold cyan]")
+        yield Input(
+            value=self.default,
+            placeholder=self.placeholder,
+            id="prompt-input"
+        )
+
+    def on_mount(self):
+        """Focus input when mounted and scroll into view."""
+        # Use call_after_refresh to ensure widget tree is ready
+        self.call_after_refresh(self._focus_input)
+
+    def _focus_input(self):
+        """Focus the input widget and scroll into view."""
+        try:
+            input_widget = self.query_one(Input)
+            # Use app.set_focus() to force focus change from steps-panel
+            self.app.set_focus(input_widget)
+            # Scroll to make this widget visible
+            self.scroll_visible(animate=False)
+        except Exception:
+            pass
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        """Handle input submission."""
+        value = event.value
+        self.on_submit_callback(value)

titan_cli/ui/tui/widgets/prompt_selection_list.py

@@ -0,0 +1,150 @@
+"""
+PromptSelectionList Widget
+
+Widget wrapper for SelectionList that handles multi-selection with checkboxes.
+"""
+
+from typing import Callable, List, Any
+from dataclasses import dataclass
+from textual.widget import Widget
+from textual.widgets import SelectionList
+from textual.widgets.selection_list import Selection
+from .text import BoldText, DimText
+
+
+@dataclass
+class SelectionOption:
+    """
+    Option for selection list.
+
+    Attributes:
+        value: The value to return when selected (can be any type)
+        label: The text to display in the list
+        selected: Whether the option is initially selected
+    """
+    value: Any
+    label: str
+    selected: bool = False
+
+
+class PromptSelectionList(Widget):
+    """
+    Widget wrapper for SelectionList that handles multi-selection events.
+
+    Displays a question and a list of options with checkboxes that the user
+    can toggle with Space and confirm with Enter.
+    """
+
+    # Allow this widget and its children to receive focus
+    can_focus = True
+    can_focus_children = True
+
+    DEFAULT_CSS = """
+    PromptSelectionList {
+        width: 100%;
+        height: auto;
+        padding: 1;
+        margin: 1 0;
+        background: $surface-lighten-1;
+        border: round $accent;
+    }
+
+    PromptSelectionList > BoldText,
+    PromptSelectionList > DimText {
+        width: 100%;
+        height: auto;
+        margin-bottom: 1;
+    }
+
+    PromptSelectionList > SelectionList {
+        width: 100%;
+        height: auto;
+        max-height: 20;
+    }
+
+    PromptSelectionList .selection-list--option {
+        padding: 0 1;
+    }
+
+    PromptSelectionList .selection-list--option-highlighted {
+        background: $accent 20%;
+    }
+    """
+
+    def __init__(
+        self,
+        question: str,
+        options: List[SelectionOption],
+        on_submit: Callable[[List[Any]], None],
+        **kwargs
+    ):
+        """
+        Initialize PromptSelectionList.
+
+        Args:
+            question: Question to display above the selection list
+            options: List of SelectionOption instances
+            on_submit: Callback that receives list of selected values
+        """
+        super().__init__(**kwargs)
+        self.question = question
+        self.options = options
+        self.on_submit_callback = on_submit
+
+    def compose(self):
+        # Question text
+        yield BoldText(self.question)
+
+        # Instructions
+        yield DimText("↑/↓: Navegar  │  Space: Seleccionar/Deseleccionar  │  Enter: Continuar")
+
+        # Create Selection objects for SelectionList
+        selections = [
+            Selection(
+                value=str(i),  # Use index as internal value
+                prompt=option.label,
+                initial_state=option.selected
+            )
+            for i, option in enumerate(self.options)
+        ]
+
+        # SelectionList widget
+        yield SelectionList(*selections, id="selection-list")
+
+    def on_mount(self):
+        """Focus selection list when mounted and scroll into view."""
+        self.call_after_refresh(self._focus_list)
+
+    def _focus_list(self):
+        """Focus the selection list widget and scroll into view."""
+        try:
+            selection_list = self.query_one(SelectionList)
+            # Use app.set_focus() to force focus change
+            self.app.set_focus(selection_list)
+            # Scroll to make this widget visible
+            self.scroll_visible(animate=False)
+        except Exception:
+            pass
+
+    def on_selection_list_selected_changed(self, event: SelectionList.SelectedChanged) -> None:
+        """Handle when user presses Enter to confirm selection."""
+        # Don't handle automatically - wait for explicit submission
+        pass
+
+    async def on_key(self, event) -> None:
+        """Intercept Enter key before it reaches SelectionList."""
+        if event.key == "enter":
+            # Stop propagation FIRST to prevent SelectionList from handling it
+            event.stop()
+            event.prevent_default()
+
+            try:
+                selection_list = self.query_one(SelectionList)
+                # Get indices of selected items
+                selected_indices = [int(sel) for sel in selection_list.selected]
+                # Map indices back to option values
+                selected_values = [self.options[i].value for i in selected_indices]
+                # Call the callback with selected values
+                self.on_submit_callback(selected_values)
+            except Exception:
+                pass

titan_cli/ui/tui/widgets/prompt_textarea.py

@@ -0,0 +1,87 @@
+"""
+PromptTextArea Widget
+
+Widget wrapper for MultilineInput that handles multiline input submission.
+"""
+
+from typing import Callable
+from textual.widget import Widget
+from .multiline_input import MultilineInput
+from .text import BoldText, DimText
+
+
+class PromptTextArea(Widget):
+    """Widget wrapper for MultilineInput that handles multiline input submission."""
+
+    can_focus = True
+    can_focus_children = True
+
+    DEFAULT_CSS = """
+    PromptTextArea {
+        width: 100%;
+        height: auto;
+        padding: 1;
+        margin: 1 0;
+        background: $surface-lighten-1;
+        border: round $accent;
+    }
+
+    PromptTextArea > BoldText,
+    PromptTextArea > DimText {
+        width: 100%;
+        height: auto;
+        margin-bottom: 1;
+    }
+
+    PromptTextArea > MultilineInput {
+        width: 100%;
+        height: auto;
+    }
+    """
+
+    def __init__(self, question: str, default: str, on_submit: Callable[[str], None], **kwargs):
+        super().__init__(**kwargs)
+        self.question = question
+        self.default = default
+        self.on_submit_callback = on_submit
+
+    def compose(self):
+        yield BoldText(self.question)
+        yield MultilineInput(
+            id="prompt-textarea",
+            soft_wrap=True
+        )
+        yield DimText("Press Ctrl+D to submit, Enter for new line")
+
+    def on_mount(self):
+        """Focus textarea when mounted and set default text."""
+        self.call_after_refresh(self._setup_textarea)
+
+    def _setup_textarea(self):
+        """Set default text, focus the textarea widget and scroll into view."""
+        try:
+            textarea = self.query_one(MultilineInput)
+            # Set default text AFTER mounting (TextArea doesn't accept text in constructor)
+            if self.default:
+                textarea.text = self.default
+                # TextArea needs a refresh to recalculate content after text change
+                # Call focus/scroll after that refresh
+                self.call_after_refresh(self._focus_and_scroll)
+            else:
+                # No default text, focus immediately
+                self._focus_and_scroll()
+        except Exception:
+            pass
+
+    def _focus_and_scroll(self):
+        """Focus and scroll the textarea after it has processed the text."""
+        try:
+            textarea = self.query_one(MultilineInput)
+            self.app.set_focus(textarea)
+            self.scroll_visible(animate=False)
+        except Exception:
+            pass
+
+    def on_multiline_input_submitted(self, message: MultilineInput.Submitted):
+        """Handle submission from MultilineInput."""
+        self.on_submit_callback(message.value)

titan_cli/ui/tui/widgets/styled_option_list.py

@@ -0,0 +1,107 @@
+"""
+StyledOptionList Widget
+
+Custom OptionList that renders options with bold titles and dim descriptions.
+Uses the same styling as BoldText and DimText components.
+"""
+
+from typing import List
+from dataclasses import dataclass
+from textual.widgets import OptionList
+from textual.widgets.option_list import Option
+
+
+@dataclass
+class StyledOption:
+    """
+    Option with styled title and description.
+
+    Attributes:
+        id: Unique identifier for the option
+        title: Title text (rendered with bold styling)
+        description: Description text (rendered with dim styling)
+        disabled: Whether the option is disabled
+    """
+    id: str
+    title: str
+    description: str = ""
+    disabled: bool = False
+
+
+class StyledOptionList(OptionList):
+    """
+    OptionList that renders options with bold titles and dim descriptions.
+
+    This widget provides a consistent way to display lists of options across
+    the application, using BoldText and DimText styling patterns.
+
+    Usage:
+        from titan_cli.ui.tui.widgets import StyledOptionList, StyledOption
+
+        options = [
+            StyledOption(
+                id="workflow1",
+                title="Release Notes",
+                description="Generate multi-brand weekly release notes"
+            ),
+            StyledOption(
+                id="workflow2",
+                title="Create PR",
+                description="Create a pull request with AI-generated description"
+            ),
+        ]
+
+        option_list = StyledOptionList(*options)
+    """
+
+    def __init__(self, *options: StyledOption, **kwargs):
+        """
+        Initialize StyledOptionList with styled options.
+
+        Args:
+            *options: StyledOption instances to display
+            **kwargs: Additional arguments passed to OptionList
+        """
+        # Convert StyledOptions to Option objects with markup
+        option_objects = []
+        for opt in options:
+            if opt.description:
+                # Title in bold, description in dim, separated by newline
+                prompt = f"[bold]{opt.title}[/bold]\n[dim]{opt.description}[/dim]"
+            else:
+                # Just title in bold
+                prompt = f"[bold]{opt.title}[/bold]"
+
+            option_objects.append(
+                Option(prompt, id=opt.id, disabled=opt.disabled)
+            )
+
+        super().__init__(*option_objects, **kwargs)
+
+    def add_styled_option(self, option: StyledOption) -> None:
+        """
+        Add a new styled option to the list.
+
+        Args:
+            option: StyledOption to add
+        """
+        if option.description:
+            prompt = f"[bold]{option.title}[/bold]\n[dim]{option.description}[/dim]"
+        else:
+            prompt = f"[bold]{option.title}[/bold]"
+
+        self.add_option(Option(prompt, id=option.id, disabled=option.disabled))
+
+    def set_styled_options(self, options: List[StyledOption]) -> None:
+        """
+        Replace all options with new styled options.
+
+        Args:
+            options: List of StyledOption instances
+        """
+        # Clear existing options
+        self.clear_options()
+
+        # Add new options
+        for opt in options:
+            self.add_styled_option(opt)