titan-cli 0.1.4__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 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 inline text
-            ctx.textual.text("Analyzing changes...")
+            # Append plain text
+            ctx.textual.text("Processing...")
 
             # Ask for input
             response = ctx.textual.ask_confirm("Continue?", default=True)
@@ -209,6 +55,48 @@ class TextualComponents:
         """
         self.app = app
         self.output_widget = output_widget
+        self._active_step_container = None
+
+    def begin_step(self, step_name: str) -> None:
+        """
+        Begin a new step by creating a StepContainer and auto-scrolling to it.
+
+        Args:
+            step_name: Name of the step
+        """
+        from titan_cli.ui.tui.widgets import StepContainer
+
+        def _create_container():
+            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)
+        except Exception:
+            pass
+
+    def end_step(self, result_type: str) -> None:
+        """
+        End the current step by updating its container color.
+
+        Args:
+            result_type: One of 'success', 'skip', 'error'
+        """
+        if not self._active_step_container:
+            return
+
+        def _update_container():
+            if self._active_step_container:
+                self._active_step_container.set_result(result_type)
+                self._active_step_container = None
+
+        try:
+            self.app.call_from_thread(_update_container)
+        except Exception:
+            pass
 
     def mount(self, widget: Widget) -> None:
         """
@@ -222,7 +110,9 @@ class TextualComponents:
             ctx.textual.mount(Panel("Success!", panel_type="success"))
         """
         def _mount():
-            self.output_widget.mount(widget)
+            # 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(widget)
 
         # call_from_thread already blocks until the function completes
         try:
@@ -231,21 +121,44 @@ class TextualComponents:
             # App is closing or worker was cancelled
             pass
 
-    def text(self, text: str, markup: str = "") -> None:
+    def scroll_to_end(self) -> None:
+        """
+        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 inline text with optional Rich markup.
+        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 markup:
-                self.output_widget.append_output(f"[{markup}]{text}[/{markup}]")
+            # If there's an active step container, append to it; otherwise to output widget
+            if self._active_step_container:
+                from textual.widgets import Static
+                widget = Static(text)
+                widget.styles.height = "auto"
+                self._active_step_container.mount(widget)
             else:
                 self.output_widget.append_output(text)
 
@@ -276,10 +189,10 @@ class TextualComponents:
         md_widget.styles.margin = (0, 0, 1, 0)
 
         def _mount():
-            # Mount markdown to output
-            self.output_widget.mount(md_widget)
-            # Trigger autoscroll after mounting
-            self.output_widget._scroll_to_end()
+            # 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)
+            # Note: Screen handles auto-scroll when step completes, not here
 
         # call_from_thread already blocks until the function completes
         try:
@@ -288,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).
@@ -443,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,
@@ -341,6 +369,14 @@ class TextualWorkflowExecutor:
                     f"Project step '{step_func_name}' not found in '.titan/steps/'.",
                     WorkflowExecutionError(f"Project step '{step_func_name}' not found")
                 )
+        elif plugin_name == "user":
+            # Handle virtual 'user' plugin for user-specific steps
+            step_func = self._workflow_registry.get_user_step(step_func_name)
+            if not step_func:
+                return Error(
+                    f"User step '{step_func_name}' not found in '~/.titan/steps/'.",
+                    WorkflowExecutionError(f"User step '{step_func_name}' not found")
+                )
         elif plugin_name == "core":
             # Handle virtual 'core' plugin for built-in core steps
             step_func = self.CORE_STEPS.get(step_func_name)
@@ -382,7 +418,7 @@ class TextualWorkflowExecutor:
                 # Plugin and project steps receive only ctx (params are in ctx.data)
                 return step_func(ctx)
         except Exception as e:
-            error_source = f"plugin '{plugin_name}'" if plugin_name not in ("project", "core") else f"{plugin_name} step"
+            error_source = f"plugin '{plugin_name}'" if plugin_name not in ("project", "user", "core") else f"{plugin_name} step"
             return Error(f"Error executing step '{step_func_name}' from {error_source}: {e}", e)
 
     def _execute_command_step(self, step_config: WorkflowStepModel, ctx: WorkflowContext) -> WorkflowResult: