titan-cli 0.1.0__py3-none-any.whl

titan_plugin_jira/steps/search_saved_query_step.py

@@ -0,0 +1,238 @@
+"""
+Search JIRA issues using saved query from utils registry
+"""
+
+from titan_cli.engine import WorkflowContext, WorkflowResult, Success, Error
+from titan_cli.ui.tui.widgets import Panel, Table
+from ..exceptions import JiraAPIError
+from ..messages import msg
+from ..utils import SAVED_QUERIES, IssueSorter
+
+
+def search_saved_query_step(ctx: WorkflowContext) -> WorkflowResult:
+    """
+    Search JIRA issues using a saved query.
+
+    Queries are predefined in utils.SAVED_QUERIES (from utils/saved_queries.py).
+    Projects can override or add custom queries in .titan/config.toml under [jira.saved_queries].
+
+    Inputs (from ctx.data):
+        query_name (str): Name of saved query (e.g., "my_bugs", "team_bugs")
+        project (str, optional): Project key for parameterized queries (e.g., "ECAPP")
+        max_results (int, optional): Maximum number of results (default: 50)
+
+    Outputs (saved to ctx.data):
+        jira_issues (list): List of JiraTicket objects
+        jira_issue_count (int): Number of issues found
+        used_query_name (str): Name of the query that was used
+
+    Returns:
+        Success: Issues found
+        Error: Query not found or search failed
+
+    Available predefined queries (from utils):
+        Personal: my_open_issues, my_bugs, my_in_review, my_in_progress
+        Team: current_sprint, team_open, team_bugs, team_in_review
+        Priority: critical_issues, high_priority, blocked_issues
+        Time: updated_today, created_this_week, recent_bugs
+        Status: todo_issues, in_progress_all, done_recently
+
+    Example usage in workflow:
+        ```yaml
+        - id: search
+          plugin: jira
+          step: search_saved_query
+          params:
+            query_name: "my_bugs"
+
+        # For queries with {project} parameter:
+        - id: search_team
+          plugin: jira
+          step: search_saved_query
+          params:
+            query_name: "team_bugs"
+            project: "ECAPP"
+        ```
+    """
+    if not ctx.textual:
+        return Error("Textual UI context is not available for this step.")
+
+    if not ctx.jira:
+        ctx.textual.mount(Panel(msg.Plugin.CLIENT_NOT_AVAILABLE_IN_CONTEXT, panel_type="error"))
+        return Error(msg.Plugin.CLIENT_NOT_AVAILABLE_IN_CONTEXT)
+
+    # Get query name
+    query_name = ctx.get("query_name")
+    if not query_name:
+        ctx.textual.mount(Panel(msg.Steps.Search.QUERY_NAME_REQUIRED, panel_type="error"))
+        return Error(msg.Steps.Search.QUERY_NAME_REQUIRED)
+
+    # Get all predefined queries from utils
+    predefined_queries = SAVED_QUERIES.get_all()
+
+    # Get custom queries from config (if any)
+    custom_queries = {}
+    try:
+        if hasattr(ctx, 'plugin_manager') and ctx.plugin_manager is not None:
+            jira_plugin = ctx.plugin_manager.get_plugin('jira')
+            if jira_plugin and hasattr(jira_plugin, '_config') and jira_plugin._config is not None:
+                custom_queries = jira_plugin._config.saved_queries or {}
+    except Exception:
+        pass
+
+    # Merge queries (custom queries override predefined)
+    all_queries = {**predefined_queries, **custom_queries}
+
+    # Look up the query
+    if query_name not in all_queries:
+        # Build helpful error message
+        predefined_list = list(predefined_queries.keys())
+        custom_list = list(custom_queries.keys())
+
+        error_msg = msg.Steps.Search.QUERY_NOT_FOUND.format(query_name=query_name) + "\n\n"
+        error_msg += msg.Steps.Search.AVAILABLE_PREDEFINED + "\n  "
+        error_msg += "\n  ".join(predefined_list[:15])
+        if len(predefined_list) > 15:
+            error_msg += "\n" + msg.Steps.Search.MORE_QUERIES.format(count=len(predefined_list) - 15)
+
+        if custom_list:
+            error_msg += "\n\n" + msg.Steps.Search.CUSTOM_QUERIES_HEADER + "\n  "
+            error_msg += "\n  ".join(custom_list)
+        else:
+            error_msg += "\n\n" + msg.Steps.Search.ADD_CUSTOM_HINT + "\n"
+            error_msg += msg.Steps.Search.CUSTOM_QUERY_EXAMPLE
+
+        ctx.textual.mount(Panel(error_msg, panel_type="error"))
+        return Error(error_msg)
+
+    jql = all_queries[query_name]
+
+    # Get parameters for query formatting
+    project = ctx.get("project")
+
+    # Format query if it has parameters
+    if "{project}" in jql:
+        if not project:
+            # Try to use default project from JIRA client
+            if ctx.jira and hasattr(ctx.jira, 'project_key'):
+                project = ctx.jira.project_key
+
+        if not project:
+            error_msg = msg.Steps.Search.PROJECT_REQUIRED.format(query_name=query_name, jql=jql)
+            ctx.textual.mount(Panel(error_msg, panel_type="error"))
+            return Error(error_msg)
+
+        jql = jql.format(project=project)
+
+    # Show which query is being used
+    is_custom = query_name in custom_queries
+    source_label = "Custom" if is_custom else "Predefined"
+
+    ctx.textual.text("")
+    ctx.textual.text(f"Using {source_label} Query: {query_name}", markup="bold")
+    ctx.textual.text(f"  JQL: {jql}", markup="dim")
+    ctx.textual.text("")
+
+    # Get max results
+    max_results = ctx.get("max_results", 50)
+
+    try:
+        # Execute search with loading indicator
+        with ctx.textual.loading("Searching JIRA issues..."):
+            issues = ctx.jira.search_tickets(jql=jql, max_results=max_results)
+
+        if not issues:
+            ctx.textual.mount(
+                Panel(
+                    text=f"No issues found for query: {query_name}",
+                    panel_type="info"
+                )
+            )
+            return Success(
+                "No issues found",
+                metadata={
+                    "jira_issues": [],
+                    "jira_issue_count": 0,
+                    "used_query_name": query_name
+                }
+            )
+
+        # Show results
+        ctx.textual.mount(
+            Panel(
+                text=f"Found {len(issues)} issues",
+                panel_type="success"
+            )
+        )
+        ctx.textual.text("")
+
+        # Show detailed table
+        ctx.textual.text("Found Issues:", markup="bold")
+        ctx.textual.text("")
+
+        try:
+            # Sort issues intelligently
+            sorter = IssueSorter()
+            sorted_issues = sorter.sort(issues)
+
+            # Prepare table data with row numbers for selection
+            headers = ["#", "Key", "Status", "Summary", "Assignee", "Type", "Priority"]
+            rows = []
+            for i, issue in enumerate(sorted_issues, 1):
+                assignee = issue.assignee or "Unassigned"
+                status = issue.status or "Unknown"
+                priority = issue.priority or "Unknown"
+                issue_type = issue.issue_type or "Unknown"
+                summary = (issue.summary or "No summary")[:60]
+
+                rows.append([
+                    str(i),
+                    issue.key,
+                    status,
+                    summary,
+                    assignee,
+                    issue_type,
+                    priority
+                ])
+
+            # Render table using textual widget
+            ctx.textual.mount(
+                Table(
+                    headers=headers,
+                    rows=rows,
+                    title=f"Issues (sorted by {sorter.get_sort_description()})"
+                )
+            )
+
+            # Use sorted issues for downstream steps
+            issues = sorted_issues
+        except Exception as e:
+            # If table rendering fails, show error but continue with raw issue list
+            ctx.textual.text(f"Error rendering table: {e}", markup="red")
+            ctx.textual.text(f"Found {len(issues)} issues (showing raw data)", markup="cyan")
+            for i, issue in enumerate(issues, 1):
+                ctx.textual.text(f"{i}. {issue.key} - {getattr(issue, 'summary', 'N/A')}")
+            ctx.textual.text("")
+
+        return Success(
+            f"Found {len(issues)} issues using query: {query_name}",
+            metadata={
+                "jira_issues": issues,
+                "jira_issue_count": len(issues),
+                "used_query_name": query_name
+            }
+        )
+
+    except JiraAPIError as e:
+        error_msg = f"JIRA search failed: {e}"
+        ctx.textual.mount(Panel(error_msg, panel_type="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.mount(Panel(error_msg, panel_type="error"))
+        return Error(error_msg)
+
+
+__all__ = ["search_saved_query_step"]

titan_plugin_jira/utils/__init__.py

@@ -0,0 +1,13 @@
+"""
+JIRA plugin utilities
+"""
+
+from .saved_queries import SavedQueries, SAVED_QUERIES
+from .issue_sorter import IssueSorter, IssueSortConfig
+
+__all__ = [
+    "SavedQueries",
+    "SAVED_QUERIES",
+    "IssueSorter",
+    "IssueSortConfig"
+]

titan_plugin_jira/utils/issue_sorter.py

@@ -0,0 +1,140 @@
+"""
+Issue Sorter Utility
+
+Provides intelligent sorting for JIRA issues based on status, priority, and key.
+"""
+
+from typing import List, Dict
+from dataclasses import dataclass
+
+
+@dataclass
+class IssueSortConfig:
+    """Configuration for issue sorting priorities."""
+
+    status_order: Dict[str, int]
+    priority_order: Dict[str, int]
+
+    @classmethod
+    def default(cls) -> "IssueSortConfig":
+        """
+        Returns default sorting configuration.
+
+        Status order: To Do → In Progress → Done
+        Priority order: Critical → High → Medium → Low
+        """
+        return cls(
+            status_order={
+                # To Do / Open states
+                "to do": 0,
+                "open": 0,
+                "backlog": 0,
+                # In Progress states
+                "in progress": 1,
+                "in review": 1,
+                "code review": 1,
+                "review": 1,
+                # Done / Closed states
+                "done": 2,
+                "closed": 2,
+                "resolved": 2,
+                "completed": 2
+            },
+            priority_order={
+                # Critical/Highest
+                "critical": 0,
+                "highest": 0,
+                "blocker": 0,
+                # High
+                "high": 1,
+                # Medium/Normal
+                "medium": 2,
+                "normal": 2,
+                # Low/Lowest
+                "low": 3,
+                "lowest": 3,
+                "trivial": 3
+            }
+        )
+
+
+class IssueSorter:
+    """
+    Sorts JIRA issues intelligently based on status, priority, and key.
+
+    Sorting criteria (in order):
+    1. Status (To Do → In Progress → Done)
+    2. Priority (Critical → High → Medium → Low)
+    3. Key (alphabetical)
+
+    Unknown statuses/priorities are placed at the end.
+
+    Example:
+        >>> from titan_plugin_jira.models import JiraTicket
+        >>> sorter = IssueSorter()
+        >>> sorted_issues = sorter.sort(issues)
+    """
+
+    def __init__(self, config: IssueSortConfig = None):
+        """
+        Initialize the sorter with optional custom configuration.
+
+        Args:
+            config: IssueSortConfig instance. If None, uses default configuration.
+        """
+        self.config = config or IssueSortConfig.default()
+        self._unknown_value = 99  # Value for unknown statuses/priorities
+
+    def sort(self, issues: List) -> List:
+        """
+        Sort issues based on status, priority, and key.
+
+        Args:
+            issues: List of JiraTicket objects
+
+        Returns:
+            Sorted list of JiraTicket objects
+
+        Example:
+            >>> sorter = IssueSorter()
+            >>> sorted_issues = sorter.sort(my_issues)
+        """
+        return sorted(issues, key=self._sort_key)
+
+    def _sort_key(self, issue) -> tuple:
+        """
+        Generate sort key for an issue.
+
+        Returns tuple of (status_order, priority_order, key) for sorting.
+        """
+        status_value = self._get_status_order(issue.status)
+        priority_value = self._get_priority_order(issue.priority)
+
+        return (status_value, priority_value, issue.key)
+
+    def _get_status_order(self, status: str) -> int:
+        """Get sort order for a status (case-insensitive)."""
+        if not status:
+            return self._unknown_value
+        return self.config.status_order.get(
+            status.lower(),
+            self._unknown_value
+        )
+
+    def _get_priority_order(self, priority: str) -> int:
+        """Get sort order for a priority (case-insensitive)."""
+        if not priority:
+            return self._unknown_value
+        return self.config.priority_order.get(
+            priority.lower(),
+            self._unknown_value
+        )
+
+    def get_sort_description(self) -> str:
+        """
+        Get human-readable description of the sort order.
+
+        Returns:
+            Description string like "Status → Priority → Key"
+        """
+        return "Status → Priority → Key"

titan_plugin_jira/utils/saved_queries.py

@@ -0,0 +1,150 @@
+"""
+Predefined JIRA saved queries registry.
+
+Common JQL queries that can be used across projects.
+Projects can extend these with custom queries in .titan/config.toml
+"""
+
+from typing import Dict
+
+
+class SavedQueries:
+    """
+    Registry of predefined JQL queries.
+
+    These are common queries that work with any JIRA instance.
+    Projects can override or extend these via config.
+    """
+
+    # ==================== PERSONAL QUERIES ====================
+
+    OPEN_ISSUES = 'project = {project} AND status IN ("Open", "Ready to Dev") ORDER BY updated DESC'
+    """All issues that are Open or Ready to Dev in the specified project (regardless of assignee), ordered by last updated"""
+
+    MY_OPEN_ISSUES = 'project = {project} AND assignee = currentUser() AND status IN ("Open", "Ready to Dev") ORDER BY updated DESC'
+    """Issues assigned to you that are Open or Ready to Dev in the specified project"""
+
+    MY_ISSUES = "assignee = currentUser() ORDER BY updated DESC"
+    """All issues assigned to you (including Done)"""
+
+    MY_BUGS = "assignee = currentUser() AND type = Bug AND status != Done"
+    """Open bugs assigned to you"""
+
+    MY_IN_REVIEW = "assignee = currentUser() AND status = 'In Review'"
+    """Issues you have in review status"""
+
+    MY_IN_PROGRESS = "assignee = currentUser() AND status = 'In Progress'"
+    """Issues you're currently working on"""
+
+    REPORTED_BY_ME = "reporter = currentUser() ORDER BY created DESC"
+    """Issues you created"""
+
+    # ==================== TEAM QUERIES ====================
+
+    CURRENT_SPRINT = "sprint in openSprints() AND project = {project}"
+    """Issues in current sprint (requires project parameter)"""
+
+    TEAM_OPEN = "project = {project} AND status != Done"
+    """All open issues in project"""
+
+    TEAM_BUGS = "project = {project} AND type = Bug AND status != Done"
+    """Open bugs in project"""
+
+    TEAM_IN_REVIEW = "project = {project} AND status = 'In Review'"
+    """Issues in review for project"""
+
+    TEAM_READY_FOR_QA = "project = {project} AND status = 'Ready for QA'"
+    """Issues ready for QA testing"""
+
+    # ==================== PRIORITY QUERIES ====================
+
+    CRITICAL_ISSUES = "priority = Highest AND status != Done ORDER BY created ASC"
+    """All critical priority issues"""
+
+    HIGH_PRIORITY = "priority IN (Highest, High) AND status != Done ORDER BY priority DESC"
+    """High and highest priority issues"""
+
+    CRITICAL_MY_PROJECT = "priority = Highest AND status != Done AND project = {project}"
+    """Critical issues in specific project"""
+
+    BLOCKED_ISSUES = "status = Blocked ORDER BY updated DESC"
+    """All blocked issues"""
+
+    # ==================== TIME-BASED QUERIES ====================
+
+    UPDATED_TODAY = "updated >= startOfDay() ORDER BY updated DESC"
+    """Issues updated today"""
+
+    UPDATED_THIS_WEEK = "updated >= startOfWeek() ORDER BY updated DESC"
+    """Issues updated this week"""
+
+    CREATED_TODAY = "created >= startOfDay() ORDER BY created DESC"
+    """Issues created today"""
+
+    CREATED_THIS_WEEK = "created >= startOfWeek() ORDER BY created DESC"
+    """Issues created this week"""
+
+    RECENT_BUGS = "type = Bug AND created >= -7d ORDER BY created DESC"
+    """Bugs created in last 7 days"""
+
+    # ==================== STATUS QUERIES ====================
+
+    TODO_ISSUES = "status = 'To Do' ORDER BY priority DESC, created ASC"
+    """All issues in To Do status"""
+
+    IN_PROGRESS_ALL = "status = 'In Progress' ORDER BY updated DESC"
+    """All issues currently in progress"""
+
+    IN_REVIEW_ALL = "status = 'In Review' ORDER BY updated DESC"
+    """All issues in review"""
+
+    DONE_RECENTLY = "status = Done AND updated >= -7d ORDER BY updated DESC"
+    """Issues completed in last 7 days"""
+
+    @classmethod
+    def get_all(cls) -> Dict[str, str]:
+        """
+        Get all predefined queries as a dictionary.
+
+        Returns:
+            Dict mapping query names to JQL strings
+        """
+        queries = {}
+        for attr in dir(cls):
+            if attr.isupper() and not attr.startswith('_'):
+                value = getattr(cls, attr)
+                if isinstance(value, str):
+                    # Convert attribute name to lowercase with underscores
+                    key = attr.lower()
+                    queries[key] = value
+        return queries
+
+    @classmethod
+    def format(cls, query_name: str, **params) -> str:
+        """
+        Format a query with parameters.
+
+        Args:
+            query_name: Name of the query (lowercase with underscores)
+            **params: Parameters to format into query
+
+        Returns:
+            Formatted JQL query
+
+        Example:
+            >>> SavedQueries.format('current_sprint', project='ECAPP')
+            'sprint in openSprints() AND project = ECAPP'
+        """
+        queries = cls.get_all()
+        if query_name not in queries:
+            raise ValueError(f"Query '{query_name}' not found")
+
+        query = queries[query_name]
+        return query.format(**params)
+
+
+# Singleton instance
+SAVED_QUERIES = SavedQueries()
+
+
+__all__ = ["SavedQueries", "SAVED_QUERIES"]

titan_plugin_jira/workflows/analyze-jira-issues.yaml

@@ -0,0 +1,34 @@
+name: "Analyze JIRA Open and Ready to Dev Issues"
+description: "List all JIRA issues in Open or Ready to Dev status and analyze selected issue with AI"
+
+params:
+  # Can override which saved query to use
+  query_name: "open_issues"
+
+steps:
+  - id: search_open_issues
+    name: "Search Open Issues"
+    plugin: jira
+    step: search_saved_query
+    params:
+      query_name: "open_issues"
+      max_results: 20
+
+  - id: prompt_select_issue
+    name: "Select Issue to Analyze"
+    plugin: jira
+    step: prompt_select_issue
+
+  - id: get_issue_details
+    name: "Get Full Issue Details"
+    plugin: jira
+    step: get_issue
+    requires:
+      - jira_issue_key
+
+  - id: ai_analyze_issue
+    name: "AI Analyze Issue"
+    plugin: jira
+    step: ai_analyze_issue_requirements
+    requires:
+      - jira_issue