titan-cli 0.1.0__py3-none-any.whl

titan_cli/ui/tui/textual_workflow_executor.py

@@ -0,0 +1,405 @@
+"""
+Textual Workflow Executor
+
+Workflow executor specifically designed for Textual TUI.
+Emits Textual messages instead of using Rich UI components.
+"""
+from typing import Any, Dict, Optional
+
+from textual.message import Message
+
+from titan_cli.core.workflows import ParsedWorkflow
+from titan_cli.core.workflows.workflow_exceptions import WorkflowExecutionError
+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.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
+
+
+class TextualWorkflowExecutor:
+    """
+    Workflow executor for Textual TUI.
+
+    Instead of using ctx.ui (Rich components), this executor emits
+    Textual messages that the screen can listen to and display.
+    """
+
+    # Core steps available to all workflows
+    CORE_STEPS = {
+        "ai_code_assistant": execute_ai_assistant_step,
+    }
+
+    # Message classes for communication with the screen
+    class WorkflowStarted(Message):
+        """Emitted when workflow execution starts."""
+        def __init__(self, workflow_name: str, description: Optional[str], source: Optional[str], total_steps: int, steps: list = None, is_nested: bool = False) -> None:
+            super().__init__()
+            self.workflow_name = workflow_name
+            self.description = description
+            self.source = source
+            self.total_steps = total_steps
+            self.steps = steps or []
+            self.is_nested = is_nested
+
+    class WorkflowCompleted(Message):
+        """Emitted when workflow completes successfully."""
+        def __init__(self, workflow_name: str, message: str, is_nested: bool = False) -> None:
+            super().__init__()
+            self.workflow_name = workflow_name
+            self.message = message
+            self.is_nested = is_nested
+
+    class WorkflowFailed(Message):
+        """Emitted when workflow fails."""
+        def __init__(self, workflow_name: str, step_name: str, error_message: str) -> None:
+            super().__init__()
+            self.workflow_name = workflow_name
+            self.step_name = step_name
+            self.error_message = error_message
+
+    class StepStarted(Message):
+        """Emitted when a step starts executing."""
+        def __init__(self, step_index: int, step_id: str, step_name: str) -> None:
+            super().__init__()
+            self.step_index = step_index
+            self.step_id = step_id
+            self.step_name = step_name
+
+    class StepCompleted(Message):
+        """Emitted when a step completes successfully."""
+        def __init__(self, step_index: int, step_id: str, step_name: str) -> None:
+            super().__init__()
+            self.step_index = step_index
+            self.step_id = step_id
+            self.step_name = step_name
+
+    class StepFailed(Message):
+        """Emitted when a step fails."""
+        def __init__(self, step_index: int, step_id: str, step_name: str, error_message: str, on_error: str) -> None:
+            super().__init__()
+            self.step_index = step_index
+            self.step_id = step_id
+            self.step_name = step_name
+            self.error_message = error_message
+            self.on_error = on_error
+
+    class StepSkipped(Message):
+        """Emitted when a step is skipped."""
+        def __init__(self, step_index: int, step_id: str, step_name: str) -> None:
+            super().__init__()
+            self.step_index = step_index
+            self.step_id = step_id
+            self.step_name = step_name
+
+    class StepOutput(Message):
+        """Emitted when a step produces output."""
+        def __init__(self, step_index: int, step_id: str, output: str) -> None:
+            super().__init__()
+            self.step_index = step_index
+            self.step_id = step_id
+            self.output = output
+
+    def __init__(
+        self,
+        plugin_registry: PluginRegistry,
+        workflow_registry: WorkflowRegistry,
+        message_target: Any = None
+    ):
+        """
+        Initialize the Textual workflow executor.
+
+        Args:
+            plugin_registry: Plugin registry for resolving plugins
+            workflow_registry: Workflow registry for resolving workflows
+            message_target: Target to post messages to (typically a Textual Widget/Screen)
+        """
+        self._plugin_registry = plugin_registry
+        self._workflow_registry = workflow_registry
+        self._message_target = message_target
+
+    def _post_message(self, message: Message) -> None:
+        """Post a message to the target if available."""
+        if self._message_target and hasattr(self._message_target, 'post_message'):
+            self._message_target.post_message(message)
+
+    def _post_message_sync(self, message: Message) -> None:
+        """Post a message synchronously (blocks until processed)."""
+        if self._message_target and hasattr(self._message_target, 'post_message'):
+            def _post():
+                self._message_target.post_message(message)
+
+            # Use call_from_thread to block until message is posted
+            if hasattr(self._message_target, 'app'):
+                try:
+                    self._message_target.app.call_from_thread(_post)
+                except Exception:
+                    # App is closing or worker was cancelled, fail silently
+                    pass
+            else:
+                # Fallback to async post if no app available
+                self._message_target.post_message(message)
+
+    def execute(
+        self,
+        workflow: ParsedWorkflow,
+        ctx: WorkflowContext,
+        params_override: Optional[Dict[str, Any]] = None
+    ) -> WorkflowResult:
+        """
+        Execute the given ParsedWorkflow.
+
+        Args:
+            workflow: The workflow to execute
+            ctx: Workflow context
+            params_override: Optional parameter overrides
+
+        Returns:
+            WorkflowResult indicating success or failure
+        """
+        # Inject Textual components into context if message_target is available
+        if self._message_target and hasattr(self._message_target, 'app'):
+            try:
+                from titan_cli.ui.tui.textual_components import TextualComponents
+                from titan_cli.ui.tui.screens.workflow_execution import WorkflowExecutionContent
+
+                app = self._message_target.app
+                output_widget = self._message_target.query_one("#execution-content", WorkflowExecutionContent)
+
+                ctx.textual = TextualComponents(app, output_widget)
+            except Exception:
+                # If we can't get the components, steps will fall back to ctx.ui
+                pass
+
+        # Merge workflow params into ctx.data with optional overrides
+        effective_params = {**workflow.params}
+        if params_override:
+            effective_params.update(params_override)
+
+        # Load params into ctx.data so steps can access them
+        ctx.data.update(effective_params)
+
+        # Inject workflow metadata into context
+        ctx.workflow_name = workflow.name
+        ctx.total_steps = len([s for s in workflow.steps if not s.get("hook")])
+
+        # Check if this is a nested workflow (called from another workflow)
+        is_nested = len(ctx._workflow_stack) > 0
+
+        # Emit workflow started event
+        self._post_message(
+            self.WorkflowStarted(
+                workflow_name=workflow.name,
+                description=workflow.description,
+                source=workflow.source,
+                total_steps=ctx.total_steps,
+                steps=workflow.steps,
+                is_nested=is_nested
+            )
+        )
+
+        ctx.enter_workflow(workflow.name)
+        try:
+            step_index = 0
+            for step_data in workflow.steps:
+                step_config = WorkflowStepModel(**step_data)
+
+                # Hooks are resolved by the registry, so we just skip the placeholder
+                if step_config.hook:
+                    continue
+
+                step_index += 1
+                ctx.current_step = step_index
+
+                step_id = step_config.id
+                step_name = step_config.name or step_id
+
+                # Emit step started event
+                self._post_message_sync(
+                    self.StepStarted(
+                        step_index=step_index,
+                        step_id=step_id,
+                        step_name=step_name
+                    )
+                )
+
+                try:
+                    if step_config.workflow:
+                        step_result = self._execute_workflow_step(step_config, ctx)
+                    elif step_config.plugin and step_config.step:
+                        step_result = self._execute_plugin_step(step_config, ctx)
+                    elif step_config.command:
+                        step_result = self._execute_command_step(step_config, ctx)
+                    else:
+                        step_result = Error(f"Invalid step configuration for '{step_id}'.")
+                except Exception as e:
+                    step_result = Error(f"An unexpected error occurred in step '{step_name}': {e}", e)
+
+                # Handle step result
+                if is_error(step_result):
+                    self._post_message_sync(
+                        self.StepFailed(
+                            step_index=step_index,
+                            step_id=step_id,
+                            step_name=step_name,
+                            error_message=step_result.message,
+                            on_error=step_config.on_error
+                        )
+                    )
+
+                    if step_config.on_error == "fail":
+                        self._post_message_sync(
+                            self.WorkflowFailed(
+                                workflow_name=workflow.name,
+                                step_name=step_name,
+                                error_message=step_result.message
+                            )
+                        )
+                        return Error(f"Workflow failed at step '{step_name}'", step_result.exception)
+                    # else: on_error == "continue" - continue to next step
+                elif is_skip(step_result):
+                    self._post_message_sync(
+                        self.StepSkipped(
+                            step_index=step_index,
+                            step_id=step_id,
+                            step_name=step_name
+                        )
+                    )
+                    if step_result.metadata:
+                        ctx.data.update(step_result.metadata)
+                else:  # Success
+                    self._post_message_sync(
+                        self.StepCompleted(
+                            step_index=step_index,
+                            step_id=step_id,
+                            step_name=step_name
+                        )
+                    )
+                    if step_result.metadata:
+                        ctx.data.update(step_result.metadata)
+
+        finally:
+            ctx.exit_workflow(workflow.name)
+
+        # Check if this is a nested workflow (called from another workflow)
+        is_nested = len(ctx._workflow_stack) > 0
+
+        # DEBUG: Log completion
+        # with open("/tmp/titan_debug.log", "a") as f:
+        #     f.write(f"[{time.time():.3f}] Workflow '{workflow.name}' completed. is_nested={is_nested}, stack={ctx._workflow_stack}\n")
+
+        # Emit workflow completed event
+        self._post_message(
+            self.WorkflowCompleted(
+                workflow_name=workflow.name,
+                message=f"Workflow '{workflow.name}' finished.",
+                is_nested=is_nested
+            )
+        )
+
+        # with open("/tmp/titan_debug.log", "a") as f:
+        #     f.write(f"[{time.time():.3f}] WorkflowCompleted message posted\n")
+
+        return Success(f"Workflow '{workflow.name}' finished.", {})
+
+    def _execute_workflow_step(self, step_config: WorkflowStepModel, ctx: WorkflowContext) -> WorkflowResult:
+        """Execute a nested workflow as a step."""
+        workflow_name = step_config.workflow
+        if not workflow_name:
+            return Error("Workflow step is missing the 'workflow' name.")
+
+        try:
+            sub_workflow = self._workflow_registry.get_workflow(workflow_name)
+            if not sub_workflow:
+                return Error(f"Nested workflow '{workflow_name}' not found.")
+        except Exception as e:
+            return Error(f"Failed to load workflow '{workflow_name}': {e}", e)
+
+        # Recursively execute the nested workflow
+        return self.execute(sub_workflow, ctx, params_override=step_config.params)
+
+    def _execute_plugin_step(self, step_config: WorkflowStepModel, ctx: WorkflowContext) -> WorkflowResult:
+        """Execute a plugin step."""
+        plugin_name = step_config.plugin
+        step_func_name = step_config.step
+        step_params = step_config.params
+
+        # Validate required context variables
+        required_vars = step_config.params.get("requires", [])
+        for var in required_vars:
+            if var not in ctx.data:
+                return Error(f"Step '{step_func_name}' is missing required context variable: '{var}'")
+
+        step_func = None
+        if plugin_name == "project":
+            # Handle virtual 'project' plugin for project-specific steps
+            step_func = self._workflow_registry.get_project_step(step_func_name)
+            if not step_func:
+                return Error(
+                    f"Project step '{step_func_name}' not found in '.titan/steps/'.",
+                    WorkflowExecutionError(f"Project 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)
+            if not step_func:
+                available = ", ".join(self.CORE_STEPS.keys())
+                return Error(
+                    f"Core step '{step_func_name}' not found. Available: {available}",
+                    WorkflowExecutionError(f"Core step '{step_func_name}' not found")
+                )
+        else:
+            # Handle regular plugins
+            plugin_instance = self._plugin_registry.get_plugin(plugin_name)
+            if not plugin_instance:
+                return Error(
+                    f"Plugin '{plugin_name}' not found or not initialized.",
+                    WorkflowExecutionError(f"Plugin '{plugin_name}' not found")
+                )
+
+            step_functions = plugin_instance.get_steps()
+            step_func = step_functions.get(step_func_name)
+            if not step_func:
+                return Error(
+                    f"Step '{step_func_name}' not found in plugin '{plugin_name}'.",
+                    WorkflowExecutionError(f"Step '{step_func_name}' not found")
+                )
+
+        # Prepare parameters for the step function
+        resolved_params = self._resolve_parameters(step_params, ctx)
+
+        # Add resolved parameters to context data so step can access them via ctx.get()
+        ctx.data.update(resolved_params)
+
+        # Execute the step function
+        try:
+            if plugin_name == "core":
+                # Core steps receive (step: WorkflowStepModel, ctx: WorkflowContext)
+                return step_func(step_config, ctx)
+            else:
+                # 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"
+            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:
+        """Execute a shell command using the dedicated external function."""
+        return execute_external_command_step(step_config, ctx)
+
+    def _resolve_parameters(self, params: Dict[str, Any], ctx: WorkflowContext) -> Dict[str, Any]:
+        """
+        Resolve parameter values by substituting placeholders from context data.
+        All workflow params are already in ctx.data.
+        """
+        from titan_cli.engine.steps.command_step import resolve_parameters_in_string
+
+        resolved = {}
+        for key, value in params.items():
+            if isinstance(value, str):
+                resolved[key] = resolve_parameters_in_string(value, ctx)
+            else:
+                resolved[key] = value  # Keep non-string parameters as is
+        return resolved

titan_cli/ui/tui/theme.py

@@ -0,0 +1,102 @@
+"""
+Titan TUI Theme
+
+Centralized theme configuration for the Textual UI.
+Defines color variables, CSS utilities, and style constants.
+"""
+
+# Titan Theme CSS - Dracula Edition (Grises y Púrpuras)
+TITAN_THEME_CSS = """
+/* Color Variables */
+$primary: #bd93f9;           /* Purple (Dracula standard) */
+$secondary: #50fa7b;         /* Green */
+$accent: #ff79c6;            /* Pink */
+$error: #ff5555;             /* Red */
+$warning: #f1fa8c;           /* Yellow */
+$success: #50fa7b;           /* Green */
+$info: #8be9fd;              /* Cyan */
+
+/* Backgrounds */
+$surface: #282a36;           
+$surface-lighten-1: #343746; 
+$surface-lighten-2: #44475a;
+
+/* Text Colors */
+$text: #f8f8f2;              /* Foreground (Almost white) */
+$text-muted: #6272a4;        /* Comment */
+$text-disabled: #44475a;     /* Disabled */
+
+/* Banner gradient colors */
+$banner-start: #6272a4;      
+$banner-mid: #bd93f9;        
+$banner-end: #ff79c6;     
+
+/* Base widget styles */
+.title {
+    color: $primary;
+    text-style: bold;
+}
+
+.subtitle {
+    color: $secondary;
+    text-style: bold;
+}
+
+.body {
+    color: $text;
+}
+
+.muted {
+    color: $text-muted;
+    text-style: italic;
+}
+
+.error-text {
+    color: $error;
+    text-style: bold;
+}
+
+.success-text {
+    color: $success;
+    text-style: bold;
+}
+
+.warning-text {
+    color: $warning;
+    text-style: bold;
+}
+
+.info-text {
+    color: $info;
+}
+
+/* Global scrollbar styles - applies to all widgets */
+* {
+    scrollbar-background: $surface;
+    scrollbar-background-hover: $surface-lighten-1;
+    scrollbar-background-active: $surface-lighten-2;
+    scrollbar-color: $primary;
+    scrollbar-color-hover: $accent;
+    scrollbar-color-active: $accent;
+    scrollbar-corner-color: $surface;
+}
+
+/* Global OptionList styles - transparent to inherit parent background */
+OptionList {
+    border: none;
+    background: transparent;
+}
+
+OptionList > .option-list--option {
+    background: transparent;
+}
+
+OptionList > .option-list--option-highlighted {
+    background: $primary;
+}
+
+Screen {
+    background: $surface;
+    color: $text;
+}
+"""

titan_cli/ui/tui/widgets/__init__.py

@@ -0,0 +1,40 @@
+"""
+Titan TUI Widgets
+
+Reusable Textual widgets for the Titan TUI.
+"""
+from .status_bar import StatusBarWidget
+from .header import HeaderWidget
+from .panel import Panel
+from .table import Table
+from .button import Button
+from .text import (
+    Text,
+    DimText,
+    BoldText,
+    PrimaryText,
+    BoldPrimaryText,
+    SuccessText,
+    ErrorText,
+    WarningText,
+    ItalicText,
+    DimItalicText,
+)
+
+__all__ = [
+    "StatusBarWidget",
+    "HeaderWidget",
+    "Panel",
+    "Table",
+    "Button",
+    "Text",
+    "DimText",
+    "BoldText",
+    "PrimaryText",
+    "BoldPrimaryText",
+    "SuccessText",
+    "ErrorText",
+    "WarningText",
+    "ItalicText",
+    "DimItalicText",
+]

titan_cli/ui/tui/widgets/button.py

@@ -0,0 +1,108 @@
+"""
+Button Widget
+
+Reusable button widget with consistent styling and variants.
+"""
+from textual.widgets import Button as TextualButton
+
+
+class Button(TextualButton):
+    """
+    Custom Button widget with consistent styling.
+
+    Fixes the focus issue (black box around text) and provides consistent variants.
+
+    Usage:
+        Button("Click Me", variant="primary", id="my-button")
+        Button("Delete", variant="error")
+        Button("Cancel", variant="default")
+
+    Available variants:
+        - primary: Primary action button (blue/accent color)
+        - default: Default button (neutral)
+        - error: Destructive action (red)
+        - success: Success action (green)
+        - warning: Warning action (yellow)
+    """
+
+    DEFAULT_CSS = """
+    Button {
+        min-width: 16;
+        height: 3;
+        margin: 0 1;
+    }
+
+    Button:focus {
+        text-style: none;
+    }
+
+    Button.-primary {
+        background: $primary;
+        color: $text;
+    }
+
+    Button.-primary:hover {
+        background: $primary-lighten-1;
+    }
+
+    Button.-primary:focus {
+        background: $primary;
+        text-style: none;
+    }
+
+    Button.-default {
+        background: $surface-lighten-2;
+        color: $text;
+    }
+
+    Button.-default:hover {
+        background: $surface-lighten-3;
+    }
+
+    Button.-default:focus {
+        background: $surface-lighten-2;
+        text-style: none;
+    }
+
+    Button.-error {
+        background: $error;
+        color: $text;
+    }
+
+    Button.-error:hover {
+        background: $error-lighten-1;
+    }
+
+    Button.-error:focus {
+        background: $error;
+        text-style: none;
+    }
+
+    Button.-success {
+        background: $success;
+        color: $text;
+    }
+
+    Button.-success:hover {
+        background: $success-lighten-1;
+    }
+
+    Button.-success:focus {
+        background: $success;
+        text-style: none;
+    }
+
+    Button.-warning {
+        background: $warning;
+        color: $text;
+    }
+
+    Button.-warning:hover {
+        background: $warning-lighten-1;
+    }
+
+    Button.-warning:focus {
+        background: $warning;
+        text-style: none;
+    }
+    """