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

titan_cli/ui/tui/textual_components.py

@@ -7,193 +7,39 @@ Steps can import widgets directly from titan_cli.ui.tui.widgets and mount them u
 """
 
 import threading
-from typing import Optional, Callable
+from typing import Optional, List, Any
 from contextlib import contextmanager
 from textual.widget import Widget
-from textual.widgets import Input, LoadingIndicator, Static, Markdown, TextArea
+from textual.widgets import LoadingIndicator, Static, Markdown
 from textual.containers import Container
-from textual.message import Message
-
-
-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):
-        from textual.widgets import Static
-        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)
-
-
-class MultilineInput(TextArea):
-    """Custom TextArea that handles Enter for submission and Shift+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 before TextArea processes them."""
-        from textual.events import Key
-
-        # Check if it's Enter without shift
-        if isinstance(event, Key) and event.key == "enter":
-            # Submit the input
-            self.post_message(self.Submitted(self, self.text))
-            event.prevent_default()
-            event.stop()
-            return
-
-        # For all other keys, let TextArea handle it
-        super()._on_key(event)
-
-
-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 > Static {
-        width: 100%;
-        height: auto;
-        margin-bottom: 1;
-    }
-
-    PromptTextArea > MultilineInput {
-        width: 100%;
-        height: auto;
-    }
-
-    PromptTextArea .hint-text {
-        width: 100%;
-        height: auto;
-        margin-top: 1;
-        color: $text-muted;
-    }
-    """
-
-    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):
-        from textual.widgets import Static
-        yield Static(f"[bold cyan]{self.question}[/bold cyan]")
-        yield MultilineInput(
-            text=self.default,
-            id="prompt-textarea",
-            soft_wrap=True
-        )
-        yield Static("[dim]Press Enter to submit, Shift+Enter for new line[/dim]", classes="hint-text")
-
-    def on_mount(self):
-        """Focus textarea when mounted and scroll into view."""
-        self.call_after_refresh(self._focus_textarea)
-
-    def _focus_textarea(self):
-        """Focus the textarea widget and scroll into view."""
-        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)
+from titan_cli.ui.tui.widgets import Panel, PromptInput, PromptTextArea, PromptSelectionList, SelectionOption, PromptChoice, ChoiceOption
 
 
 class TextualComponents:
     """
     Textual UI utilities for workflow steps.
 
-    Steps import widgets directly (Panel, DimText, etc.) and use these utilities to:
-    - Mount widgets to the output panel
-    - Append simple text with markup
+    All text styling uses the theme system for consistent colors across themes.
+
+    Steps can use these utilities to:
+    - Display panels with consistent styling
+    - Append text with theme-based styling
     - Request user input interactively
+    - Mount custom widgets to the output panel
 
     Example:
-        from titan_cli.ui.tui.widgets import Panel, DimText
-
         def my_step(ctx):
-            # Mount a panel widget
-            ctx.textual.mount(Panel("Warning message", panel_type="warning"))
+            # Show a panel
+            ctx.textual.panel("Warning message", panel_type="warning")
 
-            # Append inline text
-            ctx.textual.text("Analyzing changes...")
+            # Append styled text (uses theme system)
+            ctx.textual.dim_text("Fetching data...")
+            ctx.textual.success_text("Operation completed!")
+            ctx.textual.error_text("Failed to connect")
+            ctx.textual.bold_primary_text("AI Analysis Results")
+
+            # Append plain text
+            ctx.textual.text("Processing...")
 
             # Ask for input
             response = ctx.textual.ask_confirm("Continue?", default=True)
@@ -213,7 +59,7 @@ class TextualComponents:
 
     def begin_step(self, step_name: str) -> None:
         """
-        Begin a new step by creating a StepContainer.
+        Begin a new step by creating a StepContainer and auto-scrolling to it.
 
         Args:
             step_name: Name of the step
@@ -224,6 +70,8 @@ class TextualComponents:
             container = StepContainer(step_name=step_name)
             self.output_widget.mount(container)
             self._active_step_container = container
+            # Auto-scroll to show the new step
+            self.output_widget._scroll_to_end()
 
         try:
             self.app.call_from_thread(_create_container)
@@ -273,33 +121,46 @@ class TextualComponents:
             # App is closing or worker was cancelled
             pass
 
-    def text(self, text: str, markup: str = "") -> None:
+    def scroll_to_end(self) -> None:
         """
-        Append inline text with optional Rich markup.
+        Scroll to the end of the output widget.
+
+        Useful for ensuring user sees newly added content in steps with lots of output.
+
+        Example:
+            ctx.textual.markdown(large_content)
+            ctx.textual.scroll_to_end()  # Ensure user sees what comes next
+        """
+        def _scroll():
+            self.output_widget._scroll_to_end()
+
+        try:
+            self.app.call_from_thread(_scroll)
+        except Exception:
+            pass
+
+    def text(self, text: str) -> None:
+        """
+        Append plain text without styling.
+
+        For styled text, use specific methods: dim_text(), success_text(), etc.
 
         Args:
             text: Text to append
-            markup: Optional Rich markup style (e.g., "cyan", "bold green")
 
         Example:
-            ctx.textual.text("Analyzing changes...", markup="cyan")
-            ctx.textual.text("Done!")
+            ctx.textual.text("Processing...")
+            ctx.textual.text("")  # Empty line
         """
         def _append():
             # If there's an active step container, append to it; otherwise to output widget
             if self._active_step_container:
                 from textual.widgets import Static
-                if markup:
-                    widget = Static(f"[{markup}]{text}[/{markup}]")
-                else:
-                    widget = Static(text)
+                widget = Static(text)
                 widget.styles.height = "auto"
                 self._active_step_container.mount(widget)
             else:
-                if markup:
-                    self.output_widget.append_output(f"[{markup}]{text}[/{markup}]")
-                else:
-                    self.output_widget.append_output(text)
+                self.output_widget.append_output(text)
 
         # call_from_thread already blocks until the function completes
         try:
@@ -331,8 +192,7 @@ class TextualComponents:
             # Mount to active step container if it exists, otherwise to output widget
             target = self._active_step_container if self._active_step_container else self.output_widget
             target.mount(md_widget)
-            # Trigger autoscroll after mounting
-            self.output_widget._scroll_to_end()
+            # Note: Screen handles auto-scroll when step completes, not here
 
         # call_from_thread already blocks until the function completes
         try:
@@ -341,6 +201,126 @@ class TextualComponents:
             # App is closing or worker was cancelled
             pass
 
+    def panel(self, text: str, panel_type: str = "info") -> None:
+        """
+        Show a panel with consistent styling.
+
+        Args:
+            text: Text to display in the panel
+            panel_type: Type of panel - "info", "success", "warning", or "error"
+
+        Example:
+            ctx.textual.panel("Operation completed successfully!", panel_type="success")
+            ctx.textual.panel("Warning: This action cannot be undone", panel_type="warning")
+        """
+        panel_widget = Panel(text=text, panel_type=panel_type)
+        self.mount(panel_widget)
+
+    def dim_text(self, text: str) -> None:
+        """
+        Append dim/muted text (uses theme system).
+
+        Args:
+            text: Text to display
+
+        Example:
+            ctx.textual.dim_text("Fetching versions for project: ECAPP")
+        """
+        from titan_cli.ui.tui.widgets import DimText
+        widget = DimText(text)
+        widget.styles.height = "auto"
+        self.mount(widget)
+
+    def success_text(self, text: str) -> None:
+        """
+        Append success text (green, uses theme system).
+
+        Args:
+            text: Text to display
+
+        Example:
+            ctx.textual.success_text("Commit created: abc1234")
+        """
+        from titan_cli.ui.tui.widgets import SuccessText
+        widget = SuccessText(text)
+        widget.styles.height = "auto"
+        self.mount(widget)
+
+    def error_text(self, text: str) -> None:
+        """
+        Append error text (red, uses theme system).
+
+        Args:
+            text: Text to display
+
+        Example:
+            ctx.textual.error_text("Failed to connect to API")
+        """
+        from titan_cli.ui.tui.widgets import ErrorText
+        widget = ErrorText(text)
+        widget.styles.height = "auto"
+        self.mount(widget)
+
+    def warning_text(self, text: str) -> None:
+        """
+        Append warning text (yellow, uses theme system).
+
+        Args:
+            text: Text to display
+
+        Example:
+            ctx.textual.warning_text("This action will overwrite existing files")
+        """
+        from titan_cli.ui.tui.widgets import WarningText
+        widget = WarningText(text)
+        widget.styles.height = "auto"
+        self.mount(widget)
+
+    def primary_text(self, text: str) -> None:
+        """
+        Append primary colored text (uses theme system).
+
+        Args:
+            text: Text to display
+
+        Example:
+            ctx.textual.primary_text("Processing items...")
+        """
+        from titan_cli.ui.tui.widgets import PrimaryText
+        widget = PrimaryText(text)
+        widget.styles.height = "auto"
+        self.mount(widget)
+
+    def bold_text(self, text: str) -> None:
+        """
+        Append bold text.
+
+        Args:
+            text: Text to display
+
+        Example:
+            ctx.textual.bold_text("Important: Read carefully")
+        """
+        from titan_cli.ui.tui.widgets import BoldText
+        widget = BoldText(text)
+        widget.styles.height = "auto"
+        self.mount(widget)
+
+    def bold_primary_text(self, text: str) -> None:
+        """
+        Append bold text with primary theme color.
+
+        Args:
+            text: Text to display
+
+        Example:
+            ctx.textual.bold_primary_text("AI Analysis Results")
+        """
+        from titan_cli.ui.tui.widgets import BoldPrimaryText
+        widget = BoldPrimaryText(text)
+        widget.styles.height = "auto"
+        self.mount(widget)
+
     def ask_text(self, question: str, default: str = "") -> Optional[str]:
         """
         Ask user for text input (blocks until user responds).
@@ -496,6 +476,130 @@ class TextualComponents:
             # Invalid response, use default
             return default
 
+    def ask_multiselect(
+        self,
+        question: str,
+        options: List[SelectionOption],
+    ) -> List[Any]:
+        """
+        Ask user to select multiple options from a list using checkboxes.
+
+        Args:
+            question: Question to display
+            options: List of SelectionOption instances
+
+        Returns:
+            List of selected values (the 'value' field from SelectionOption)
+
+        Example:
+            from titan_cli.ui.tui.widgets import SelectionOption
+
+            options = [
+                SelectionOption(value="option1", label="First Option", selected=True),
+                SelectionOption(value="option2", label="Second Option", selected=True),
+                SelectionOption(value="option3", label="Third Option", selected=False),
+            ]
+
+            selected = ctx.textual.ask_multiselect(
+                "Select options to include:",
+                options
+            )
+            # selected might be ["option1", "option2"] if user didn't change anything
+        """
+        result_container = {"result": None, "ready": threading.Event()}
+
+        def on_submit(selected_values: List[Any]):
+            result_container["result"] = selected_values
+            result_container["ready"].set()
+
+        # Create and mount the selection widget
+        selection_widget = PromptSelectionList(
+            question=question,
+            options=options,
+            on_submit=on_submit
+        )
+
+        self.mount(selection_widget)
+
+        # Wait for user to submit
+        result_container["ready"].wait()
+
+        # Remove the widget
+        def _remove():
+            try:
+                selection_widget.remove()
+            except Exception:
+                pass
+
+        try:
+            self.app.call_from_thread(_remove)
+        except Exception:
+            pass
+
+        return result_container["result"]
+
+    def ask_choice(
+        self,
+        question: str,
+        options: List[ChoiceOption],
+    ) -> Any:
+        """
+        Ask user to select one option from multiple choices using buttons.
+
+        Args:
+            question: Question to display
+            options: List of ChoiceOption instances
+
+        Returns:
+            The selected value (the 'value' field from ChoiceOption)
+
+        Example:
+            from titan_cli.ui.tui.widgets import ChoiceOption
+
+            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 = ctx.textual.ask_choice(
+                "What would you like to do with this PR description?",
+                options
+            )
+            # choice might be "use", "edit", or "reject"
+        """
+        result_container = {"result": None, "ready": threading.Event()}
+
+        def on_select(selected_value: Any):
+            result_container["result"] = selected_value
+            result_container["ready"].set()
+
+        # Create and mount the choice widget
+        choice_widget = PromptChoice(
+            question=question,
+            options=options,
+            on_select=on_select
+        )
+
+        self.mount(choice_widget)
+
+        # Wait for user to select
+        result_container["ready"].wait()
+
+        # Remove the widget
+        def _remove():
+            try:
+                choice_widget.remove()
+            except Exception:
+                pass
+
+        try:
+            self.app.call_from_thread(_remove)
+        except Exception:
+            pass
+
+        return result_container["result"]
+
     @contextmanager
     def loading(self, message: str = "Loading..."):
         """

titan_cli/ui/tui/textual_workflow_executor.py

@@ -14,7 +14,7 @@ from titan_cli.core.workflows.workflow_registry import WorkflowRegistry
 from titan_cli.core.plugins.plugin_registry import PluginRegistry
 from titan_cli.core.workflows.models import WorkflowStepModel
 from titan_cli.engine.context import WorkflowContext
-from titan_cli.engine.results import WorkflowResult, Success, Error, is_error, is_skip
+from titan_cli.engine.results import WorkflowResult, Success, Error, is_error, is_skip, is_exit
 from titan_cli.engine.steps.command_step import execute_command_step as execute_external_command_step
 from titan_cli.engine.steps.ai_assistant_step import execute_ai_assistant_step
 
@@ -238,7 +238,35 @@ class TextualWorkflowExecutor:
                     step_result = Error(f"An unexpected error occurred in step '{step_name}': {e}", e)
 
                 # Handle step result
-                if is_error(step_result):
+                if is_exit(step_result):
+                    # Exit workflow immediately (not an error)
+                    if step_result.metadata:
+                        ctx.data.update(step_result.metadata)
+
+                    # Post completion message
+                    self._post_message_sync(
+                        self.StepCompleted(
+                            step_index=step_index,
+                            step_id=step_id,
+                            step_name=step_name
+                        )
+                    )
+
+                    # Calculate is_nested before exiting workflow
+                    # (check if there are parent workflows in the stack)
+                    is_nested = len(ctx._workflow_stack) > 1  # >1 because current workflow is still in stack
+
+                    # Post workflow completed message and exit
+                    self._post_message_sync(
+                        self.WorkflowCompleted(
+                            workflow_name=workflow.name,
+                            message=step_result.message,
+                            is_nested=is_nested
+                        )
+                    )
+                    return Success(step_result.message, step_result.metadata)
+
+                elif is_error(step_result):
                     self._post_message_sync(
                         self.StepFailed(
                             step_index=step_index,

titan_cli/ui/tui/theme.py

@@ -17,8 +17,8 @@ $success: #50fa7b;           /* Green */
 $info: #8be9fd;              /* Cyan */
 
 /* Backgrounds */
-$surface: #282a36;           
-$surface-lighten-1: #343746; 
+$surface: #282a36;
+$surface-lighten-1: #343746;
 $surface-lighten-2: #44475a;
 
 /* Text Colors */
@@ -27,9 +27,9 @@ $text-muted: #6272a4;        /* Comment */
 $text-disabled: #44475a;     /* Disabled */
 
 /* Banner gradient colors */
-$banner-start: #6272a4;      
-$banner-mid: #bd93f9;        
-$banner-end: #ff79c6;     
+$banner-start: #6272a4;
+$banner-mid: #bd93f9;
+$banner-end: #ff79c6;
 
 /* Base widget styles */
 .title {
@@ -70,6 +70,35 @@ $banner-end: #ff79c6;
     color: $info;
 }
 
+/* Text widget styles (from widgets/text.py) */
+.dim, DimText, DimItalicText {
+    color: $text-muted;
+}
+
+.bold, BoldText, BoldPrimaryText {
+    text-style: bold;
+}
+
+.italic, ItalicText, DimItalicText {
+    text-style: italic;
+}
+
+.primary, PrimaryText, BoldPrimaryText {
+    color: $primary;
+}
+
+.success, SuccessText {
+    color: $success;
+}
+
+.error, ErrorText {
+    color: $error;
+}
+
+.warning, WarningText {
+    color: $warning;
+}
+
 /* Global scrollbar styles - applies to all widgets */
 * {
     scrollbar-background: $surface;

titan_cli/ui/tui/widgets/__init__.py

@@ -9,6 +9,12 @@ from .panel import Panel
 from .table import Table
 from .button import Button
 from .step_container import StepContainer
+from .multiline_input import MultilineInput
+from .prompt_input import PromptInput
+from .prompt_textarea import PromptTextArea
+from .prompt_selection_list import PromptSelectionList, SelectionOption
+from .prompt_choice import PromptChoice, ChoiceOption
+from .styled_option_list import StyledOptionList, StyledOption
 from .text import (
     Text,
     DimText,
@@ -29,6 +35,15 @@ __all__ = [
     "Table",
     "Button",
     "StepContainer",
+    "MultilineInput",
+    "PromptInput",
+    "PromptTextArea",
+    "PromptSelectionList",
+    "SelectionOption",
+    "PromptChoice",
+    "ChoiceOption",
+    "StyledOptionList",
+    "StyledOption",
     "Text",
     "DimText",
     "BoldText",