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

titan_cli/core/workflows/project_step_source.py

@@ -1,4 +1,5 @@
 import importlib.util
+import sys
 from pathlib import Path
 from typing import Callable, Dict, Any, Optional, List
 from dataclasses import dataclass
@@ -31,6 +32,7 @@ class BaseStepSource:
     def discover(self) -> List[StepInfo]:
         """
         Discovers all available step files in the project's .titan/steps directory.
+        Supports subdirectories (e.g., .titan/steps/jira/step.py).
         """
         if self._step_info_cache is not None:
             return self._step_info_cache
@@ -40,18 +42,18 @@ class BaseStepSource:
             return []
 
         discovered = []
-        for step_file in self._steps_dir.glob("*.py"):
-            if step_file.name not in self.EXCLUDED_FILES:
+        for step_file in self._steps_dir.glob("**/*.py"):
+            if step_file.name not in self.EXCLUDED_FILES and not any(part.startswith("__") for part in step_file.parts):
                 step_name = step_file.stem
                 discovered.append(StepInfo(name=step_name, path=step_file))
-        
+
         self._step_info_cache = discovered
         return discovered
 
     def get_step(self, step_name: str) -> Optional[StepFunction]:
         """
         Retrieves a step function by name, loading it from its file if necessary.
-        Searches all Python files in the directory for the function.
+        Searches all Python files in the directory (including subdirectories) for the function.
         """
         if step_name in self._step_function_cache:
             return self._step_function_cache[step_name]
@@ -59,9 +61,9 @@ class BaseStepSource:
         if not self._steps_dir.is_dir():
             return None
 
-        # Search all Python files for the function
-        for step_file in self._steps_dir.glob("*.py"):
-            if step_file.name in self.EXCLUDED_FILES:
+        # Search all Python files (including subdirectories) for the function
+        for step_file in self._steps_dir.glob("**/*.py"):
+            if step_file.name in self.EXCLUDED_FILES or any(part.startswith("__") for part in step_file.parts):
                 continue
 
             try:
@@ -88,11 +90,54 @@ class BaseStepSource:
 class ProjectStepSource(BaseStepSource):
     """
     Discovers and loads Python step functions from a project's .titan/steps/ directory.
+    Supports relative imports by properly setting module __package__ attribute.
     """
     def __init__(self, project_root: Path):
         steps_dir = project_root / ".titan" / "steps"
         super().__init__(steps_dir)
         self._project_root = project_root
+        self._titan_dir = project_root / ".titan"
+
+        # Add .titan directory to sys.path to enable absolute imports
+        titan_dir_str = str(self._titan_dir)
+        if titan_dir_str not in sys.path:
+            sys.path.insert(0, titan_dir_str)
+
+    def get_step(self, step_name: str) -> Optional[StepFunction]:
+        """
+        Retrieves a step function by name.
+        Project steps should use absolute imports from .titan/ as the root.
+        """
+        if step_name in self._step_function_cache:
+            return self._step_function_cache[step_name]
+
+        if not self._steps_dir.is_dir():
+            return None
+
+        # Search all Python files for the function
+        for step_file in self._steps_dir.glob("**/*.py"):
+            if step_file.name in self.EXCLUDED_FILES or any(part.startswith("__") for part in step_file.parts):
+                continue
+
+            try:
+                # Use a unique module name to avoid conflicts
+                module_name = f"_titan_step_{step_file.stem}_{id(step_file)}"
+                spec = importlib.util.spec_from_file_location(module_name, step_file)
+                if spec and spec.loader:
+                    module = importlib.util.module_from_spec(spec)
+                    spec.loader.exec_module(module)
+
+                    # Look for the function
+                    step_func = getattr(module, step_name, None)
+                    if callable(step_func):
+                        self._step_function_cache[step_name] = step_func
+                        return step_func
+
+            except Exception:
+                # Continue searching other files
+                continue
+
+        return None
 
 
 class UserStepSource(BaseStepSource):

titan_cli/core/workflows/workflow_filter_service.py

@@ -45,10 +45,12 @@ class WorkflowFilterService:
             if wf_info.required_plugins:
                 # Filter out core/project pseudo-plugins
                 real_plugins = [p for p in wf_info.required_plugins if p not in ["core", "project"]]
-                if real_plugins:
-                    # Use the first real plugin
-                    primary_plugin = sorted(real_plugins)[0]
-                    return primary_plugin.capitalize()
+                # If workflow uses multiple plugins, treat as custom/project workflow
+                if len(real_plugins) > 1:
+                    return "Project"
+                elif len(real_plugins) == 1:
+                    # Single plugin dependency
+                    return real_plugins[0].capitalize()
             # No plugin dependencies, it's a custom workflow
             return "Custom"
 

titan_cli/engine/__init__.py

@@ -5,7 +5,7 @@ This module provides the execution engine for composing and running workflows
 using the Atomic Steps Pattern.
 
 Core components:
-- WorkflowResult types (Success, Error, Skip)
+- WorkflowResult types (Success, Error, Skip, Exit)
 - WorkflowContext for dependency injection
 - WorkflowContextBuilder for fluent API
 - WorkflowExecutor for executing YAML workflows (see workflow_executor.py)
@@ -16,9 +16,11 @@ from .results import (
     Success,
     Error,
     Skip,
+    Exit,
     is_success,
     is_error,
     is_skip,
+    is_exit,
 )
 from .context import WorkflowContext
 from .builder import WorkflowContextBuilder
@@ -29,10 +31,12 @@ __all__ = [
     "Success",
     "Error",
     "Skip",
+    "Exit",
     # Helper functions
     "is_success",
     "is_error",
     "is_skip",
+    "is_exit",
     # Context & builder
     "WorkflowContext",
     "WorkflowContextBuilder",

titan_cli/engine/results.py

@@ -68,8 +68,33 @@ class Skip:
     metadata: Optional[dict[str, Any]] = None
 
 
+@dataclass(frozen=True)
+class Exit:
+    """
+    Exit the entire workflow early (not an error).
+
+    Use when the workflow should stop because it's not needed:
+    - No changes to commit
+    - Nothing to do
+    - Preconditions not met
+
+    This exits the ENTIRE workflow, not just the current step.
+
+    Attributes:
+        message: Why the workflow is exiting (required)
+        metadata: Metadata to auto-merge into ctx.data
+
+    Examples:
+        >>> if not has_changes:
+        >>>     return Exit("No changes to commit")
+        >>> return Exit("Already up to date", metadata={"status": "clean"})
+    """
+    message: str
+    metadata: Optional[dict[str, Any]] = None
+
+
 # Type alias for workflow results
-WorkflowResult = Union[Success, Error, Skip]
+WorkflowResult = Union[Success, Error, Skip, Exit]
 
 
 # ============================================================================
@@ -89,3 +114,8 @@ def is_error(result: WorkflowResult) -> bool:
 def is_skip(result: WorkflowResult) -> bool:
     """Check if result is Skip."""
     return isinstance(result, Skip)
+
+
+def is_exit(result: WorkflowResult) -> bool:
+    """Check if result is Exit."""
+    return isinstance(result, Exit)

titan_cli/engine/steps/ai_assistant_step.py

@@ -56,13 +56,13 @@ def execute_ai_assistant_step(step: WorkflowStepModel, ctx: WorkflowContext) ->
     # Validate cli_preference
     VALID_CLI_PREFERENCES = {"auto", "claude", "gemini"}
     if cli_preference not in VALID_CLI_PREFERENCES:
-        ctx.textual.text(f"Invalid cli_preference: {cli_preference}. Must be one of {VALID_CLI_PREFERENCES}", markup="red")
+        ctx.textual.error_text(f"Invalid cli_preference: {cli_preference}. Must be one of {VALID_CLI_PREFERENCES}")
         ctx.textual.end_step("error")
         return Error(f"Invalid cli_preference: {cli_preference}. Must be one of {VALID_CLI_PREFERENCES}")
 
     # Validate required parameters
     if not context_key:
-        ctx.textual.text(msg.AIAssistant.CONTEXT_KEY_REQUIRED, markup="red")
+        ctx.textual.error_text(msg.AIAssistant.CONTEXT_KEY_REQUIRED)
         ctx.textual.end_step("error")
         return Error(msg.AIAssistant.CONTEXT_KEY_REQUIRED)
 
@@ -79,7 +79,7 @@ def execute_ai_assistant_step(step: WorkflowStepModel, ctx: WorkflowContext) ->
         else:
             friendly_msg = "No issues to fix - skipping AI assistance"
 
-        ctx.textual.text(friendly_msg, markup="dim")
+        ctx.textual.dim_text(friendly_msg)
         ctx.textual.end_step("skip")
         return Skip(friendly_msg)
 
@@ -96,11 +96,11 @@ def execute_ai_assistant_step(step: WorkflowStepModel, ctx: WorkflowContext) ->
             context_str = json.dumps(context_data, indent=2)
             prompt = prompt_template.format(context=context_str)
     except KeyError as e:
-        ctx.textual.text(msg.AIAssistant.INVALID_PROMPT_TEMPLATE.format(e=e), markup="red")
+        ctx.textual.error_text(msg.AIAssistant.INVALID_PROMPT_TEMPLATE.format(e=e))
         ctx.textual.end_step("error")
         return Error(msg.AIAssistant.INVALID_PROMPT_TEMPLATE.format(e=e))
     except Exception as e:
-        ctx.textual.text(msg.AIAssistant.FAILED_TO_BUILD_PROMPT.format(e=e), markup="red")
+        ctx.textual.error_text(msg.AIAssistant.FAILED_TO_BUILD_PROMPT.format(e=e))
         ctx.textual.end_step("error")
         return Error(msg.AIAssistant.FAILED_TO_BUILD_PROMPT.format(e=e))
 
@@ -113,10 +113,10 @@ def execute_ai_assistant_step(step: WorkflowStepModel, ctx: WorkflowContext) ->
         )
         if not should_launch:
             if fail_on_decline:
-                ctx.textual.text(msg.AIAssistant.DECLINED_ASSISTANCE_STOPPED, markup="yellow")
+                ctx.textual.warning_text(msg.AIAssistant.DECLINED_ASSISTANCE_STOPPED)
                 ctx.textual.end_step("error")
                 return Error(msg.AIAssistant.DECLINED_ASSISTANCE_STOPPED)
-            ctx.textual.text(msg.AIAssistant.DECLINED_ASSISTANCE_SKIPPED, markup="dim")
+            ctx.textual.dim_text(msg.AIAssistant.DECLINED_ASSISTANCE_SKIPPED)
             ctx.textual.end_step("skip")
             return Skip(msg.AIAssistant.DECLINED_ASSISTANCE_SKIPPED)
 
@@ -142,7 +142,7 @@ def execute_ai_assistant_step(step: WorkflowStepModel, ctx: WorkflowContext) ->
                 available_launchers[cli_name] = launcher
 
     if not available_launchers:
-        ctx.textual.text(msg.AIAssistant.NO_ASSISTANT_CLI_FOUND, markup="yellow")
+        ctx.textual.warning_text(msg.AIAssistant.NO_ASSISTANT_CLI_FOUND)
         ctx.textual.end_step("skip")
         return Skip(msg.AIAssistant.NO_ASSISTANT_CLI_FOUND)
 
@@ -151,7 +151,7 @@ def execute_ai_assistant_step(step: WorkflowStepModel, ctx: WorkflowContext) ->
     else:
         # Show available CLIs with numbers
         ctx.textual.text("")  # spacing
-        ctx.textual.text(msg.AIAssistant.SELECT_ASSISTANT_CLI, markup="bold cyan")
+        ctx.textual.bold_primary_text(msg.AIAssistant.SELECT_ASSISTANT_CLI)
 
         cli_options = list(available_launchers.keys())
         for idx, cli_name in enumerate(cli_options, 1):
@@ -162,7 +162,7 @@ def execute_ai_assistant_step(step: WorkflowStepModel, ctx: WorkflowContext) ->
         choice_str = ctx.textual.ask_text("Select option (or press Enter to cancel):", default="")
 
         if not choice_str or choice_str.strip() == "":
-            ctx.textual.text(msg.AIAssistant.DECLINED_ASSISTANCE_SKIPPED, markup="dim")
+            ctx.textual.dim_text(msg.AIAssistant.DECLINED_ASSISTANCE_SKIPPED)
             ctx.textual.end_step("skip")
             return Skip(msg.AIAssistant.DECLINED_ASSISTANCE_SKIPPED)
 
@@ -171,17 +171,17 @@ def execute_ai_assistant_step(step: WorkflowStepModel, ctx: WorkflowContext) ->
             if 0 <= choice_idx < len(cli_options):
                 cli_to_launch = cli_options[choice_idx]
             else:
-                ctx.textual.text("Invalid option selected", markup="red")
+                ctx.textual.error_text("Invalid option selected")
                 ctx.textual.end_step("skip")
                 return Skip(msg.AIAssistant.DECLINED_ASSISTANCE_SKIPPED)
         except ValueError:
-            ctx.textual.text("Invalid input - must be a number", markup="red")
+            ctx.textual.error_text("Invalid input - must be a number")
             ctx.textual.end_step("skip")
             return Skip(msg.AIAssistant.DECLINED_ASSISTANCE_SKIPPED)
 
     # Validate selection
     if cli_to_launch not in available_launchers:
-        ctx.textual.text(f"Unknown CLI to launch: {cli_to_launch}", markup="red")
+        ctx.textual.error_text(f"Unknown CLI to launch: {cli_to_launch}")
         ctx.textual.end_step("error")
         return Error(f"Unknown CLI to launch: {cli_to_launch}")
 
@@ -189,13 +189,13 @@ def execute_ai_assistant_step(step: WorkflowStepModel, ctx: WorkflowContext) ->
 
     # Launch the CLI
     ctx.textual.text("")  # spacing
-    ctx.textual.text(msg.AIAssistant.LAUNCHING_ASSISTANT.format(cli_name=cli_name), markup="cyan")
+    ctx.textual.primary_text(msg.AIAssistant.LAUNCHING_ASSISTANT.format(cli_name=cli_name))
 
     # Show prompt preview
     prompt_preview_text = msg.AIAssistant.PROMPT_PREVIEW.format(
         prompt_preview=f"{prompt[:100]}..." if len(prompt) > 100 else prompt
     )
-    ctx.textual.text(prompt_preview_text, markup="dim")
+    ctx.textual.dim_text(prompt_preview_text)
     ctx.textual.text("")  # spacing
 
     project_root = ctx.get("project_root", ".")
@@ -208,13 +208,13 @@ def execute_ai_assistant_step(step: WorkflowStepModel, ctx: WorkflowContext) ->
     )
 
     ctx.textual.text("")  # spacing
-    ctx.textual.text(msg.AIAssistant.BACK_IN_TITAN, markup="green")
+    ctx.textual.success_text(msg.AIAssistant.BACK_IN_TITAN)
 
     if exit_code != 0:
-        ctx.textual.text(msg.AIAssistant.ASSISTANT_EXITED_WITH_CODE.format(cli_name=cli_name, exit_code=exit_code), markup="yellow")
+        ctx.textual.warning_text(msg.AIAssistant.ASSISTANT_EXITED_WITH_CODE.format(cli_name=cli_name, exit_code=exit_code))
         ctx.textual.end_step("error")
         return Error(msg.AIAssistant.ASSISTANT_EXITED_WITH_CODE.format(cli_name=cli_name, exit_code=exit_code))
 
-    ctx.textual.text(msg.AIAssistant.ASSISTANT_EXITED_WITH_CODE.format(cli_name=cli_name, exit_code=exit_code), markup="green")
+    ctx.textual.success_text(msg.AIAssistant.ASSISTANT_EXITED_WITH_CODE.format(cli_name=cli_name, exit_code=exit_code))
     ctx.textual.end_step("success")
     return Success(msg.AIAssistant.ASSISTANT_EXITED_WITH_CODE.format(cli_name=cli_name, exit_code=exit_code), metadata={"ai_exit_code": exit_code})

titan_cli/engine/workflow_executor.py

@@ -4,7 +4,7 @@ from typing import Any, Dict, Optional
 from titan_cli.core.workflows import ParsedWorkflow
 from titan_cli.core.workflows.workflow_exceptions import WorkflowExecutionError
 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.core.workflows.workflow_registry import WorkflowRegistry
 from titan_cli.core.plugins.plugin_registry import PluginRegistry
 from titan_cli.core.workflows.models import WorkflowStepModel
@@ -75,7 +75,12 @@ class WorkflowExecutor:
                     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 immediately - workflow is done (not an error)
+                    if step_result.metadata:
+                        ctx.data.update(step_result.metadata)
+                    return Success(step_result.message, step_result.metadata)
+                elif is_error(step_result):
                     if step_config.on_error == "fail":
                         return Error(f"Workflow failed at step '{step_name}'", step_result.exception)
                     # else: on_error == "continue" - continue to next step

titan_cli/ui/tui/screens/plugin_config_wizard.py

@@ -567,6 +567,22 @@ class PluginConfigWizardScreen(BaseScreen):
             # Save secrets
             project_name = self.config.get_project_name()
             for secret_key, secret_value in secrets_to_save.items():
+                # Clean up old secrets for this key to avoid conflicts
+                # This prevents accumulation of stale tokens from previous configurations
+                if self.plugin_name == "jira" and "api_token" in secret_key:
+                    # Delete all possible old JIRA token variants
+                    old_keys = [
+                        secret_key,  # Generic: jira_api_token
+                        f"{project_name}_{secret_key}" if project_name else None,  # Project-specific
+                    ]
+                    for old_key in old_keys:
+                        if old_key:
+                            try:
+                                self.config.secrets.delete(old_key, scope="user")
+                            except Exception:
+                                pass  # Ignore errors if key doesn't exist
+
+                # Save the new secret
                 keychain_key = f"{project_name}_{secret_key}" if project_name else secret_key
                 self.config.secrets.set(keychain_key, secret_value, scope="user")
 

titan_cli/ui/tui/screens/workflow_execution.py

@@ -146,16 +146,16 @@ class WorkflowExecutionScreen(BaseScreen):
                 thread=True
             )
 
-        except (WorkflowNotFoundError, WorkflowExecutionError):
-            pass
-            # TODO Create empty error screen
-            # self._update_workflow_info(f"[red]Error: {e}[/red]")
-        except Exception:
-            pass
-            # TODO Create empty error screen
-            # self._update_workflow_info(
-            #     f"[red]Unexpected error: {type(e).__name__} - {e}[/red]"
-            # )
+        except (WorkflowNotFoundError, WorkflowExecutionError) as e:
+            self._output(f"[red]{Icons.ERROR} Error loading workflow: {e}[/red]")
+            self._output("[dim]Press ESC or Q to return[/dim]")
+        except Exception as e:
+            import traceback
+            error_details = traceback.format_exc()
+            self._output(f"[red]{Icons.ERROR} Unexpected error loading workflow:[/red]")
+            self._output(f"[red]{type(e).__name__}: {e}[/red]")
+            self._output(f"[dim]{error_details}[/dim]")
+            self._output("[dim]Press ESC or Q to return[/dim]")
 
     def _execute_workflow(self) -> None:
         """Execute the workflow in a background thread."""
@@ -493,12 +493,14 @@ class WorkflowExecutionContent(Widget):
 
     def on_descendant_mount(self, event) -> None:
         """Auto-scroll when any widget is mounted as a descendant."""
-        # Don't auto-scroll if we're mounting a PromptInput (it will handle its own scroll)
-        from titan_cli.ui.tui.textual_components import PromptInput
+        from titan_cli.ui.tui.widgets import PromptInput, StepContainer
 
-        # Skip scroll only if the widget itself is a PromptInput
-        # (not if it's a child of PromptInput, to avoid blocking scroll after PromptInput is removed)
-        if not isinstance(event.widget, PromptInput):
+        # Auto-scroll for StepContainers (new steps being added)
+        # StepContainer itself triggers scroll via begin_step(), but this is a safety net
+        if isinstance(event.widget, StepContainer):
+            self._scroll_to_end()
+        # Also scroll for other widgets, but skip PromptInput (it handles its own scroll)
+        elif not isinstance(event.widget, PromptInput):
             self._scroll_to_end()
 
     def handle_event(self, message) -> None:
@@ -520,13 +522,9 @@ class WorkflowExecutionContent(Widget):
             pass
 
         elif isinstance(message, TextualWorkflowExecutor.StepFailed):
-            # StepContainer now handles step failures (red border), so we don't display the panel
-            # Only show "continuing despite error" message if on_error is "continue"
-            if message.on_error == "continue":
-                indent = "  " * self._workflow_depth if self._workflow_depth > 0 else ""
-                self.append_output(f"[yellow]{indent}   {Icons.WARNING}  Continuing despite error[/yellow]\n")
-            else:
-                self.append_output("")
+            # Steps handle their own error display via ctx.textual
+            # Executor only coordinates execution, no visual output needed
+            pass
 
         elif isinstance(message, TextualWorkflowExecutor.StepSkipped):
             # StepContainer now handles step skips (yellow border), so we don't display the panel
@@ -566,7 +564,7 @@ class WorkflowExecutionContent(Widget):
                 pass
 
         elif isinstance(message, TextualWorkflowExecutor.WorkflowFailed):
-            # Show error toast for workflow failure
+            # Steps handle their own error display via ctx.textual
+            # Just show a simple notification without duplicating the error message
             self.app.notify(f"❌ Workflow failed at step: {message.step_name}", severity="error", timeout=10)
-            self.append_output(f"[red]{message.error_message}[/red]")
 

titan_cli/ui/tui/screens/workflows.py

@@ -16,6 +16,7 @@ from titan_cli.core.workflows.workflow_filter_service import WorkflowFilterServi
 from titan_cli.core.workflows.workflow_sources import WorkflowInfo
 from titan_cli.ui.tui.screens.workflow_execution import WorkflowExecutionScreen
 from titan_cli.ui.tui.icons import Icons
+from titan_cli.ui.tui.widgets import StyledOption
 from .base import BaseScreen
 
 class WorkflowsScreen(BaseScreen):
@@ -170,11 +171,14 @@ class WorkflowsScreen(BaseScreen):
             workflows_to_show = workflows
 
         for wf_info in workflows_to_show:
-            label = f"{wf_info.name.capitalize()}"
-            description = f"{wf_info.description}"
-            options.append(
-                Option(f"{label}\n[dim]{description}[/dim]", id=wf_info.name)
+            styled_opt = StyledOption(
+                id=wf_info.name,
+                title=wf_info.name.capitalize(),
+                description=wf_info.description
             )
+            # Convert StyledOption to Option with markup
+            prompt = f"[bold]{styled_opt.title}[/bold]\n[dim]{styled_opt.description}[/dim]"
+            options.append(Option(prompt, id=styled_opt.id))
 
         return options if options else [Option("No workflows found", id="none", disabled=True)]