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

titan_plugin_github/steps/issue_steps.py

@@ -1,8 +1,8 @@
 import ast
 from titan_cli.engine.context import WorkflowContext
 from titan_cli.engine.results import WorkflowResult, Success, Error, Skip
-from titan_cli.ui.tui.widgets import Panel
 from ..agents.issue_generator import IssueGeneratorAgent
+from pathlib import Path
 
 def ai_suggest_issue_title_and_body_step(ctx: WorkflowContext) -> WorkflowResult:
     """
@@ -12,15 +12,21 @@ def ai_suggest_issue_title_and_body_step(ctx: WorkflowContext) -> WorkflowResult
     if not ctx.textual:
         return Error("Textual UI context is not available for this step.")
 
+    # Begin step container
+    ctx.textual.begin_step("Categorize and Generate Issue")
+
     if not ctx.ai:
+        ctx.textual.dim_text("AI client not available")
+        ctx.textual.end_step("skip")
         return Skip("AI client not available")
 
     issue_body_prompt = ctx.get("issue_body")
     if not issue_body_prompt:
+        ctx.textual.error_text("issue_body not found in context")
+        ctx.textual.end_step("error")
         return Error("issue_body not found in context")
 
-    ctx.textual.text("Using AI to categorize and generate issue...", markup="cyan")
-
+    ctx.textual.dim_text("Using AI to categorize and generate issue...")
     try:
         # Get available labels from repository for smart mapping
         available_labels = None
@@ -34,7 +40,6 @@ def ai_suggest_issue_title_and_body_step(ctx: WorkflowContext) -> WorkflowResult
         # Get template directory from repo path
         template_dir = None
         if ctx.git:
-            from pathlib import Path
             template_dir = Path(ctx.git.repo_path) / ".github" / "ISSUE_TEMPLATE"
 
         issue_generator = IssueGeneratorAgent(ctx.ai, template_dir=template_dir)
@@ -46,25 +51,24 @@ def ai_suggest_issue_title_and_body_step(ctx: WorkflowContext) -> WorkflowResult
         category = result["category"]
         template_used = result.get("template_used", False)
 
-        ctx.textual.mount(
-            Panel(
-                text=f"Category detected: {category}",
-                panel_type="success"
-            )
-        )
+        ctx.textual.text("")  # spacing
+        ctx.textual.success_text(f"Category detected: {category}")
 
         if template_used:
-            ctx.textual.text(f"Using template: {category}.md", markup="cyan")
+            ctx.textual.success_text(f"Using template: {category}.md")
         else:
-            ctx.textual.text(f"No template found for {category}, using default structure", markup="yellow")
+            ctx.textual.warning_text(f"No template found for {category}, using default structure")
 
         ctx.set("issue_title", result["title"])
         ctx.set("issue_body", result["body"])
         ctx.set("issue_category", category)
         ctx.set("labels", result["labels"])
 
+        ctx.textual.end_step("success")
         return Success(f"AI-generated issue ({category}) created successfully")
     except Exception as e:
+        ctx.textual.error_text(f"Failed to generate issue: {e}")
+        ctx.textual.end_step("error")
         return Error(f"Failed to generate issue: {e}")
 
 
@@ -75,7 +79,12 @@ def create_issue_steps(ctx: WorkflowContext) -> WorkflowResult:
     if not ctx.textual:
         return Error("Textual UI context is not available for this step.")
 
+    # Begin step container
+    ctx.textual.begin_step("Create Issue")
+
     if not ctx.github:
+        ctx.textual.error_text("GitHub client not available")
+        ctx.textual.end_step("error")
         return Error("GitHub client not available")
 
     issue_title = ctx.get("issue_title")
@@ -103,9 +112,13 @@ def create_issue_steps(ctx: WorkflowContext) -> WorkflowResult:
         labels = []
 
     if not issue_title:
+        ctx.textual.error_text("issue_title not found in context")
+        ctx.textual.end_step("error")
         return Error("issue_title not found in context")
 
     if not issue_body:
+        ctx.textual.error_text("issue_body not found in context")
+        ctx.textual.end_step("error")
         return Error("issue_body not found in context")
 
     # Filter labels to only those that exist in the repository
@@ -123,21 +136,21 @@ def create_issue_steps(ctx: WorkflowContext) -> WorkflowResult:
             pass
 
     try:
+        ctx.textual.dim_text(f"Creating issue: {issue_title}...")
         issue = ctx.github.create_issue(
             title=issue_title,
             body=issue_body,
             assignees=assignees,
             labels=labels,
         )
-        ctx.textual.mount(
-            Panel(
-                text=f"Successfully created issue #{issue.number}",
-                panel_type="success"
-            )
-        )
+        ctx.textual.text("")  # spacing
+        ctx.textual.success_text(f"Successfully created issue #{issue.number}")
+        ctx.textual.end_step("success")
         return Success(
             f"Successfully created issue #{issue.number}",
             metadata={"issue": issue}
         )
     except Exception as e:
+        ctx.textual.error_text(f"Failed to create issue: {e}")
+        ctx.textual.end_step("error")
         return Error(f"Failed to create issue: {e}")

titan_plugin_github/steps/preview_step.py

@@ -8,24 +8,29 @@ def preview_and_confirm_issue_step(ctx: WorkflowContext) -> WorkflowResult:
     if not ctx.textual:
         return Error("Textual UI context is not available for this step.")
 
+    # Begin step container
+    ctx.textual.begin_step("Preview and Confirm Issue")
+
     issue_title = ctx.get("issue_title")
     issue_body = ctx.get("issue_body")
 
     if not issue_title or not issue_body:
+        ctx.textual.error_text("issue_title or issue_body not found in context")
+        ctx.textual.end_step("error")
         return Error("issue_title or issue_body not found in context")
 
     # Show preview header
     ctx.textual.text("")  # spacing
-    ctx.textual.text("AI-Generated Issue Preview", markup="bold")
+    ctx.textual.bold_text("AI-Generated Issue Preview")
     ctx.textual.text("")  # spacing
 
     # Show title
-    ctx.textual.text("Title:", markup="bold")
-    ctx.textual.text(f"  {issue_title}", markup="cyan")
+    ctx.textual.bold_text("Title:")
+    ctx.textual.primary_text(f"  {issue_title}")
     ctx.textual.text("")  # spacing
 
     # Show description
-    ctx.textual.text("Description:", markup="bold")
+    ctx.textual.bold_text("Description:")
     # Render markdown in a scrollable container
     ctx.textual.markdown(issue_body)
 
@@ -33,8 +38,14 @@ def preview_and_confirm_issue_step(ctx: WorkflowContext) -> WorkflowResult:
 
     try:
         if not ctx.textual.ask_confirm("Use this AI-generated issue?", default=True):
+            ctx.textual.warning_text("User rejected AI-generated issue")
+            ctx.textual.end_step("error")
             return Error("User rejected AI-generated issue")
     except (KeyboardInterrupt, EOFError):
+        ctx.textual.error_text("User cancelled operation")
+        ctx.textual.end_step("error")
         return Error("User cancelled operation")
 
+    ctx.textual.success_text("User confirmed AI-generated issue")
+    ctx.textual.end_step("success")
     return Success("User confirmed AI-generated issue")

titan_plugin_github/utils.py

@@ -54,21 +54,22 @@ def calculate_pr_size(diff: str) -> PRSizeEstimation:
     files_changed = len(re.findall(file_pattern, diff, re.MULTILINE))
 
     # Dynamic character limit based on PR size
+    # Increased limits to accommodate PR templates with images/GIFs
     if files_changed <= 3 and diff_lines < 100:
         # Small PR: bug fix, doc update, small feature
-        max_chars = 800
+        max_chars = 1500
         pr_size = "small"
     elif files_changed <= 10 and diff_lines < 500:
         # Medium PR: feature, moderate refactor
-        max_chars = 1800
+        max_chars = 2500
         pr_size = "medium"
     elif files_changed <= 30 and diff_lines < 2000:
         # Large PR: architectural changes, new modules
-        max_chars = 3000
+        max_chars = 4000
         pr_size = "large"
     else:
         # Very large PR: major refactor, breaking changes
-        max_chars = 4500
+        max_chars = 6000
         pr_size = "very large"
 
     return PRSizeEstimation(

titan_plugin_github/workflows/create-pr-ai.yaml

@@ -19,7 +19,13 @@ steps:
     plugin: git
     step: get_current_branch
 
+  - id: branch_diff_summary
+    name: "Show Branch Changes Summary"
+    plugin: git
+    step: show_branch_diff_summary
+
   # AI generates PR title and description from branch commits
+  # User can choose to use as-is, edit, or reject
   - id: ai_pr_description
     name: "AI PR Description"
     plugin: github
@@ -27,17 +33,6 @@ steps:
 
   - hook: before_push
 
-  # Fallback to manual prompts if AI was rejected
-  - id: prompt_pr_title
-    name: "Prompt for PR Title"
-    plugin: github
-    step: prompt_for_pr_title
-
-  - id: prompt_pr_body
-    name: "Prompt for PR Body"
-    plugin: github
-    step: prompt_for_pr_body
-
   - id: create_pr
     name: "Create Pull Request"
     plugin: github

titan_plugin_jira/messages.py

@@ -101,6 +101,18 @@ class Messages:
             ISSUE_SELECTION_CONFIRM: str = "Selected: {key} - {summary}"
             SELECT_SUCCESS: str = "Selected issue: {key}"
 
+        class ReleaseNotes:
+            """Release notes generation step messages"""
+            AI_NOT_AVAILABLE: str = "AI not available, using original JIRA summaries"
+            AI_GENERATION_FAILED: str = "AI generation failed: {error}"
+            USING_FALLBACK_SUMMARIES: str = "Using original JIRA summaries as fallback"
+            PROCESSING_ISSUES: str = "Processing {count} issues for version {version}"
+            GROUPED_BRANDS: str = "Grouped into {count} brands"
+            GENERATING_AI_DESCRIPTIONS: str = "Generating AI descriptions..."
+            SUCCESS: str = "Release notes generated successfully!"
+            COPY_INSTRUCTIONS: str = "Copy the markdown above and paste it into your release notes"
+            NO_ISSUES_FOUND: str = "No JIRA issues found to generate release notes"
+
     class JIRA:
         """JIRA-specific messages"""
         AUTHENTICATION_FAILED: str = "JIRA authentication failed. Check your API token."

titan_plugin_jira/plugin.py

@@ -243,14 +243,18 @@ class JiraPlugin(TitanPlugin):
         Returns a dictionary of available workflow steps.
         """
         from .steps.search_saved_query_step import search_saved_query_step
+        from .steps.search_jql_step import search_jql_step
         from .steps.prompt_select_issue_step import prompt_select_issue_step
         from .steps.get_issue_step import get_issue_step
         from .steps.ai_analyze_issue_step import ai_analyze_issue_requirements_step
+        from .steps.list_versions_step import list_versions_step
         return {
             "search_saved_query": search_saved_query_step,
+            "search_jql": search_jql_step,
             "prompt_select_issue": prompt_select_issue_step,
             "get_issue": get_issue_step,
             "ai_analyze_issue_requirements": ai_analyze_issue_requirements_step,
+            "list_versions": list_versions_step,
         }
 
     @property

titan_plugin_jira/steps/ai_analyze_issue_step.py

@@ -3,7 +3,6 @@ AI-powered JIRA issue analysis step
 """
 
 from titan_cli.engine import WorkflowContext, WorkflowResult, Success, Error, Skip
-from titan_cli.ui.tui.widgets import Panel
 from ..messages import msg
 from ..agents import JiraAgent
 from ..formatters import IssueAnalysisMarkdownFormatter
@@ -32,15 +31,20 @@ def ai_analyze_issue_requirements_step(ctx: WorkflowContext) -> WorkflowResult:
     if not ctx.textual:
         return Error("Textual UI context is not available for this step.")
 
+    # Begin step container
+    ctx.textual.begin_step("AI Analyze Issue")
+
     # Check if AI is available
     if not ctx.ai or not ctx.ai.is_available():
-        ctx.textual.mount(Panel(msg.Steps.AIIssue.AI_NOT_CONFIGURED_SKIP, panel_type="info"))
+        ctx.textual.dim_text(msg.Steps.AIIssue.AI_NOT_CONFIGURED_SKIP)
+        ctx.textual.end_step("skip")
         return Skip(msg.Steps.AIIssue.AI_NOT_CONFIGURED)
 
     # Get issue to analyze
     issue = ctx.get("jira_issue") or ctx.get("selected_issue")
     if not issue:
-        ctx.textual.mount(Panel(msg.Steps.AIIssue.NO_ISSUE_FOUND, panel_type="error"))
+        ctx.textual.error_text(msg.Steps.AIIssue.NO_ISSUE_FOUND)
+        ctx.textual.end_step("error")
         return Error(msg.Steps.AIIssue.NO_ISSUE_FOUND)
 
     # Create JiraAgent instance and analyze issue with loading indicator
@@ -61,12 +65,12 @@ def ai_analyze_issue_requirements_step(ctx: WorkflowContext) -> WorkflowResult:
 
     # Display analysis
     ctx.textual.text("")
-    ctx.textual.text("AI Analysis Results", markup="bold cyan")
+    ctx.textual.bold_primary_text("AI Analysis Results")
     ctx.textual.text("")
 
     # Show issue header
-    ctx.textual.text(f"{issue.key}: {issue.summary}", markup="bold")
-    ctx.textual.text(f"Type: {issue.issue_type} | Status: {issue.status} | Priority: {issue.priority}", markup="dim")
+    ctx.textual.bold_text(f"{issue.key}: {issue.summary}")
+    ctx.textual.dim_text(f"Type: {issue.issue_type} | Status: {issue.status} | Priority: {issue.priority}")
     ctx.textual.text("")
 
     # Show AI analysis as markdown
@@ -74,7 +78,7 @@ def ai_analyze_issue_requirements_step(ctx: WorkflowContext) -> WorkflowResult:
 
     # Show token usage
     if analysis.total_tokens_used > 0:
-        ctx.textual.text(f"Tokens used: {analysis.total_tokens_used}", markup="dim")
+        ctx.textual.dim_text(f"Tokens used: {analysis.total_tokens_used}")
 
     # Save structured analysis to context
     ctx.set("ai_analysis_structured", {
@@ -90,6 +94,7 @@ def ai_analyze_issue_requirements_step(ctx: WorkflowContext) -> WorkflowResult:
         "estimated_effort": analysis.estimated_effort
     })
 
+    ctx.textual.end_step("success")
     return Success(
         "AI analysis completed",
         metadata={

titan_plugin_jira/steps/get_issue_step.py

@@ -3,7 +3,6 @@ Get JIRA issue details step
 """
 
 from titan_cli.engine import WorkflowContext, WorkflowResult, Success, Error
-from titan_cli.ui.tui.widgets import Panel
 from ..exceptions import JiraAPIError
 from ..messages import msg
 
@@ -26,15 +25,20 @@ def get_issue_step(ctx: WorkflowContext) -> WorkflowResult:
     if not ctx.textual:
         return Error("Textual UI context is not available for this step.")
 
+    # Begin step container
+    ctx.textual.begin_step("Get Full Issue Details")
+
     # Check if JIRA client is available
     if not ctx.jira:
-        ctx.textual.mount(Panel(msg.Plugin.CLIENT_NOT_AVAILABLE_IN_CONTEXT, panel_type="error"))
+        ctx.textual.error_text(msg.Plugin.CLIENT_NOT_AVAILABLE_IN_CONTEXT)
+        ctx.textual.end_step("error")
         return Error(msg.Plugin.CLIENT_NOT_AVAILABLE_IN_CONTEXT)
 
     # Get issue key
     issue_key = ctx.get("jira_issue_key")
     if not issue_key:
-        ctx.textual.mount(Panel("JIRA issue key is required", panel_type="error"))
+        ctx.textual.error_text("JIRA issue key is required")
+        ctx.textual.end_step("error")
         return Error("JIRA issue key is required")
 
     # Get optional expand fields
@@ -46,20 +50,17 @@ def get_issue_step(ctx: WorkflowContext) -> WorkflowResult:
             issue = ctx.jira.get_ticket(ticket_key=issue_key, expand=expand)
 
         # Show success
-        ctx.textual.mount(
-            Panel(
-                text=msg.Steps.GetIssue.GET_SUCCESS.format(issue_key=issue_key),
-                panel_type="success"
-            )
-        )
+        ctx.textual.text("")  # spacing
+        ctx.textual.success_text(msg.Steps.GetIssue.GET_SUCCESS.format(issue_key=issue_key))
 
         # Show issue details
-        ctx.textual.text(f"  Title: {issue.summary}", markup="cyan")
+        ctx.textual.primary_text(f"  Title: {issue.summary}")
         ctx.textual.text(f"  Status: {issue.status}")
         ctx.textual.text(f"  Type: {issue.issue_type}")
         ctx.textual.text(f"  Assignee: {issue.assignee or 'Unassigned'}")
         ctx.textual.text("")
 
+        ctx.textual.end_step("success")
         return Success(
             msg.Steps.GetIssue.GET_SUCCESS.format(issue_key=issue_key),
             metadata={"jira_issue": issue}
@@ -68,14 +69,17 @@ def get_issue_step(ctx: WorkflowContext) -> WorkflowResult:
     except JiraAPIError as e:
         if e.status_code == 404:
             error_msg = msg.Steps.GetIssue.ISSUE_NOT_FOUND.format(issue_key=issue_key)
-            ctx.textual.mount(Panel(error_msg, panel_type="error"))
+            ctx.textual.error_text(error_msg)
+            ctx.textual.end_step("error")
             return Error(error_msg)
         error_msg = msg.Steps.GetIssue.GET_FAILED.format(e=e)
-        ctx.textual.mount(Panel(error_msg, panel_type="error"))
+        ctx.textual.error_text(error_msg)
+        ctx.textual.end_step("error")
         return Error(error_msg)
     except Exception as e:
         error_msg = f"Unexpected error getting issue: {e}"
-        ctx.textual.mount(Panel(error_msg, panel_type="error"))
+        ctx.textual.error_text(error_msg)
+        ctx.textual.end_step("error")
         return Error(error_msg)
 
 

titan_plugin_jira/steps/list_versions_step.py

@@ -0,0 +1,133 @@
+"""
+List available versions (fixVersions) for a JIRA project
+"""
+
+from titan_cli.engine import WorkflowContext, WorkflowResult, Success, Error
+from ..exceptions import JiraAPIError
+
+
+def list_versions_step(ctx: WorkflowContext) -> WorkflowResult:
+    """
+    List unreleased versions for a JIRA project.
+
+    Filters and returns only versions that are not yet released,
+    sorted by name in descending order (most recent first).
+
+    Inputs (from ctx.data):
+        project_key (str, optional): Project key. If not provided, uses default_project from JIRA plugin config.
+
+    Outputs (saved to ctx.data):
+        versions (list): List of unreleased version names
+        versions_full (list): List of full unreleased version objects
+
+    Returns:
+        Success: Unreleased versions listed
+        Error: Failed to fetch versions or project_key not configured
+
+    Example usage in workflow:
+        ```yaml
+        - id: list_versions
+          plugin: jira
+          step: list_versions
+          params:
+            project_key: "MYPROJECT"
+        ```
+    """
+    if not ctx.textual:
+        return Error("Textual UI context is not available for this step.")
+
+    if not ctx.jira:
+        return Error("JIRA client not available in context")
+
+    # Begin step container
+    ctx.textual.begin_step("List Project Versions")
+
+    # Get project key from context or fall back to default_project from JIRA client
+    project_key = ctx.get("project_key")
+    if not project_key:
+        # Try to use default project from JIRA client config
+        if hasattr(ctx.jira, 'project_key') and ctx.jira.project_key:
+            project_key = ctx.jira.project_key
+            ctx.textual.dim_text(f"Using default project from JIRA config: {project_key}")
+        else:
+            ctx.textual.error_text("project_key is required but not provided")
+            ctx.textual.dim_text("Set project_key in workflow params or configure default_project in JIRA plugin")
+            ctx.textual.end_step("error")
+            return Error("project_key is required. Provide it in workflow params or configure default_project in JIRA plugin.")
+
+    # Show fetching message
+    ctx.textual.dim_text(f"Fetching versions for project: {project_key}")
+    ctx.textual.text("")
+
+    try:
+        # Get project details which includes versions
+        project = ctx.jira.get_project(project_key)
+        versions = project.get("versions", [])
+
+        if not versions:
+            ctx.textual.panel(
+                f"No versions found for project {project_key}", panel_type="info"
+            )
+            ctx.textual.end_step("skip")
+            return Success(
+                "No versions found", metadata={"versions": [], "versions_full": []}
+            )
+
+        # Filter only unreleased versions for release notes workflow
+        unreleased_versions = [v for v in versions if not v.get("released", False)]
+
+        # Sort unreleased by name descending (most recent first)
+        unreleased_versions.sort(key=lambda v: v.get("name", ""), reverse=True)
+
+        # Use only unreleased versions
+        sorted_versions = unreleased_versions
+
+        # Extract version names
+        version_names = [v.get("name", "") for v in sorted_versions]
+
+        # Show success panel
+        ctx.textual.text("")
+        ctx.textual.panel(
+            f"Found {len(sorted_versions)} unreleased versions",
+            panel_type="success",
+        )
+
+        # Show versions list
+        ctx.textual.text("")
+        ctx.textual.bold_primary_text("Unreleased Versions:")
+        ctx.textual.text("")
+
+        for v in sorted_versions[:20]:  # Show first 20
+            name = v.get("name", "")
+            description = v.get("description", "")
+            desc_text = f" - {description[:50]}" if description else ""
+            ctx.textual.primary_text(f"  • {name}{desc_text}")
+
+        if len(sorted_versions) > 20:
+            ctx.textual.dim_text(
+                f"  ... and {len(sorted_versions) - 20} more"
+            )
+        ctx.textual.text("")
+
+        ctx.textual.end_step("success")
+        return Success(
+            f"Found {len(sorted_versions)} unreleased versions",
+            metadata={"versions": version_names, "versions_full": sorted_versions},
+        )
+
+    except JiraAPIError as e:
+        error_msg = f"Failed to fetch versions: {e}"
+        ctx.textual.panel(error_msg, panel_type="error")
+        ctx.textual.end_step("error")
+        return Error(error_msg)
+    except Exception as e:
+        import traceback
+
+        error_detail = traceback.format_exc()
+        error_msg = f"Unexpected error: {e}\n\nTraceback:\n{error_detail}"
+        ctx.textual.panel(error_msg, panel_type="error")
+        ctx.textual.end_step("error")
+        return Error(error_msg)
+
+
+__all__ = ["list_versions_step"]

titan_plugin_jira/steps/prompt_select_issue_step.py

@@ -3,7 +3,6 @@ Prompt user to select an issue from search results
 """
 
 from titan_cli.engine import WorkflowContext, WorkflowResult, Success, Error
-from titan_cli.ui.tui.widgets import Panel
 from ..messages import msg
 
 
@@ -21,12 +20,19 @@ def prompt_select_issue_step(ctx: WorkflowContext) -> WorkflowResult:
     if not ctx.textual:
         return Error("Textual UI context is not available for this step.")
 
+    # Begin step container
+    ctx.textual.begin_step("Select Issue to Analyze")
+
     # Get issues from previous search
     issues = ctx.get("jira_issues")
     if not issues:
+        ctx.textual.error_text(msg.Steps.PromptSelectIssue.NO_ISSUES_AVAILABLE)
+        ctx.textual.end_step("error")
         return Error(msg.Steps.PromptSelectIssue.NO_ISSUES_AVAILABLE)
 
     if len(issues) == 0:
+        ctx.textual.error_text(msg.Steps.PromptSelectIssue.NO_ISSUES_AVAILABLE)
+        ctx.textual.end_step("error")
         return Error(msg.Steps.PromptSelectIssue.NO_ISSUES_AVAILABLE)
 
     # Prompt user to select issue (issues already displayed in table from previous step)
@@ -40,32 +46,36 @@ def prompt_select_issue_step(ctx: WorkflowContext) -> WorkflowResult:
         )
 
         if not response or not response.strip():
+            ctx.textual.error_text(msg.Steps.PromptSelectIssue.NO_ISSUE_SELECTED)
+            ctx.textual.end_step("error")
             return Error(msg.Steps.PromptSelectIssue.NO_ISSUE_SELECTED)
 
         # Validate it's a number
         try:
             selected_index = int(response.strip())
         except ValueError:
+            ctx.textual.error_text(f"Invalid input: '{response}' is not a number")
+            ctx.textual.end_step("error")
             return Error(f"Invalid input: '{response}' is not a number")
 
         # Validate it's in range
         if selected_index < 1 or selected_index > len(issues):
+            ctx.textual.error_text(f"Invalid selection: must be between 1 and {len(issues)}")
+            ctx.textual.end_step("error")
             return Error(f"Invalid selection: must be between 1 and {len(issues)}")
 
         # Convert to 0-based index
         selected_issue = issues[selected_index - 1]
 
         ctx.textual.text("")
-        ctx.textual.mount(
-            Panel(
-                text=msg.Steps.PromptSelectIssue.ISSUE_SELECTION_CONFIRM.format(
-                    key=selected_issue.key,
-                    summary=selected_issue.summary
-                ),
-                panel_type="success"
+        ctx.textual.success_text(
+            msg.Steps.PromptSelectIssue.ISSUE_SELECTION_CONFIRM.format(
+                key=selected_issue.key,
+                summary=selected_issue.summary
             )
         )
 
+        ctx.textual.end_step("success")
         return Success(
             msg.Steps.PromptSelectIssue.SELECT_SUCCESS.format(key=selected_issue.key),
             metadata={
@@ -74,6 +84,8 @@ def prompt_select_issue_step(ctx: WorkflowContext) -> WorkflowResult:
             }
         )
     except (KeyboardInterrupt, EOFError):
+        ctx.textual.error_text("User cancelled issue selection")
+        ctx.textual.end_step("error")
         return Error("User cancelled issue selection")