titan-cli 0.1.0__py3-none-any.whl

titan_plugin_github/steps/ai_pr_step.py

@@ -0,0 +1,172 @@
+# plugins/titan-plugin-github/titan_plugin_github/steps/ai_pr_step.py
+"""
+AI-powered PR description generation step.
+
+Uses PRAgent to analyze branch context and generate PR content.
+"""
+
+from titan_cli.engine import WorkflowContext, WorkflowResult, Success, Error, Skip
+from titan_cli.ui.tui.widgets import Panel
+
+from ..agents import PRAgent
+from ..messages import msg
+
+
+def ai_suggest_pr_description_step(ctx: WorkflowContext) -> WorkflowResult:
+    """
+    Generate PR title and description using PRAgent.
+
+    Uses PRAgent to analyze the complete branch context and generate:
+    - PR title following conventional commits
+    - PR description following template (if exists)
+    - Appropriate detail level based on PR size
+
+    Requires:
+        ctx.ai: An initialized AIClient
+        ctx.git: An initialized GitClient
+        ctx.github: An initialized GitHubClient
+
+    Inputs (from ctx.data):
+        pr_head_branch (str): The head branch for the PR
+
+    Outputs (saved to ctx.data):
+        pr_title (str): AI-generated PR title
+        pr_body (str): AI-generated PR description
+        pr_size (str): Size classification (small/medium/large/very large)
+        ai_generated (bool): True if AI generated the content
+
+    Returns:
+        Success: PR description generated
+        Skip: AI not configured or user declined
+        Error: Failed to generate PR description
+    """
+    if not ctx.textual:
+        return Error("Textual UI context is not available for this step.")
+
+    # Check if AI is configured
+    if not ctx.ai or not ctx.ai.is_available():
+        ctx.textual.mount(
+            Panel(
+                text=msg.GitHub.AI.AI_NOT_CONFIGURED,
+                panel_type="info"
+            )
+        )
+        return Skip(msg.GitHub.AI.AI_NOT_CONFIGURED)
+
+    # Get Git client
+    if not ctx.git:
+        return Error(msg.GitHub.AI.GIT_CLIENT_NOT_AVAILABLE)
+
+    # Get branch info
+    head_branch = ctx.get("pr_head_branch")
+    if not head_branch:
+        return Error(msg.GitHub.AI.MISSING_PR_HEAD_BRANCH)
+
+    base_branch = ctx.git.main_branch
+
+    try:
+        # Show progress
+        ctx.textual.text(msg.GitHub.AI.ANALYZING_BRANCH_DIFF.format(
+            head_branch=head_branch,
+            base_branch=base_branch
+        ), markup="dim")
+
+        # Create PRAgent instance
+        pr_agent = PRAgent(
+            ai_client=ctx.ai,
+            git_client=ctx.git,
+            github_client=ctx.github
+        )
+
+        # Use PRAgent to analyze and generate PR content with loading indicator
+        with ctx.textual.loading(msg.GitHub.AI.GENERATING_PR_DESCRIPTION):
+            analysis = pr_agent.analyze_and_plan(
+                head_branch=head_branch,
+                base_branch=base_branch,
+                auto_stage=False  # Only analyze branch commits, not uncommitted changes
+            )
+
+        # Check if PR content was generated (need commits in branch)
+        if not analysis.pr_title or not analysis.pr_body:
+            ctx.textual.mount(
+                Panel(
+                    text="No commits found in branch to generate PR description.",
+                    panel_type="info"
+                )
+            )
+            return Skip("No commits found for PR generation")
+
+        # Show PR size info
+        if analysis.pr_size:
+            ctx.textual.text(msg.GitHub.AI.PR_SIZE_INFO.format(
+                pr_size=analysis.pr_size,
+                files_changed=analysis.files_changed,
+                diff_lines=analysis.lines_changed,
+                max_chars="varies by size"
+            ), markup="dim")
+
+        # Show PR preview to user
+        ctx.textual.text("")  # spacing
+        ctx.textual.text(msg.GitHub.AI.AI_GENERATED_PR_TITLE, markup="bold")
+        ctx.textual.text("")  # spacing
+
+        # Show title
+        ctx.textual.text(msg.GitHub.AI.TITLE_LABEL, markup="bold")
+        ctx.textual.text(f"  {analysis.pr_title}", markup="cyan")
+
+        # Warn if title is too long
+        if len(analysis.pr_title) > 72:
+            ctx.textual.text(msg.GitHub.AI.TITLE_TOO_LONG_WARNING.format(
+                length=len(analysis.pr_title)
+            ), markup="yellow")
+
+        ctx.textual.text("")  # spacing
+
+        # Show description
+        ctx.textual.text(msg.GitHub.AI.DESCRIPTION_LABEL, markup="bold")
+        # Render markdown in a scrollable container
+        ctx.textual.markdown(analysis.pr_body)
+
+        ctx.textual.text("")  # spacing
+
+        # Single confirmation for both title and description
+        use_ai_pr = ctx.textual.ask_confirm(
+            msg.GitHub.AI.CONFIRM_USE_AI_PR,
+            default=True
+        )
+
+        if not use_ai_pr:
+            ctx.textual.text(msg.GitHub.AI.AI_SUGGESTION_REJECTED, markup="yellow")
+            return Skip("User rejected AI-generated PR")
+
+        # Show success panel
+        ctx.textual.mount(
+            Panel(
+                text="AI generated PR description successfully",
+                panel_type="success"
+            )
+        )
+
+        # Success - save to context
+        metadata = {
+            "ai_generated": True,
+            "pr_title": analysis.pr_title,
+            "pr_body": analysis.pr_body,
+            "pr_size": analysis.pr_size
+        }
+
+        return Success(
+            msg.GitHub.AI.AI_GENERATED_PR_DESCRIPTION_SUCCESS,
+            metadata=metadata
+        )
+
+    except Exception as e:
+        # Don't fail the workflow, just skip AI and use manual prompts
+        ctx.textual.text(msg.GitHub.AI.AI_GENERATION_FAILED.format(e=e), markup="yellow")
+        ctx.textual.text(msg.GitHub.AI.FALLBACK_TO_MANUAL, markup="dim")
+
+        return Skip(msg.GitHub.AI.AI_GENERATION_FAILED.format(e=e))
+
+
+# Export for plugin registration
+__all__ = ["ai_suggest_pr_description_step"]

titan_plugin_github/steps/create_pr_step.py

@@ -0,0 +1,86 @@
+# plugins/titan-plugin-github/titan_plugin_github/steps/create_pr_step.py
+from titan_cli.engine import WorkflowContext, WorkflowResult, Success, Error
+from titan_cli.ui.tui.widgets import Panel
+from ..exceptions import GitHubAPIError
+from ..messages import msg
+
+
+def create_pr_step(ctx: WorkflowContext) -> WorkflowResult:
+    """
+    Creates a GitHub pull request using data from the workflow context.
+
+    Requires:
+        ctx.github: An initialized GitHubClient.
+        ctx.git: An initialized GitClient.
+
+    Inputs (from ctx.data):
+        pr_title (str): The title of the pull request.
+        pr_body (str, optional): The body/description of the pull request.
+        pr_head_branch (str): The branch with the new changes.
+        pr_is_draft (bool, optional): Whether to create the PR as a draft. Defaults to False.
+
+    Configuration (from ctx.github.config):
+        auto_assign_prs (bool): If True, automatically assigns the PR to the current GitHub user.
+
+    Outputs (saved to ctx.data):
+        pr_number (int): The number of the created pull request.
+        pr_url (str): The URL of the created pull request.
+
+    Returns:
+        Success: If the PR is created successfully.
+        Error: If any required context arguments are missing or if the API call fails.
+    """
+    if not ctx.textual:
+        return Error("Textual UI context is not available for this step.")
+
+    # 1. Get GitHub client from context
+    if not ctx.github:
+        return Error("GitHub client is not available in the workflow context.")
+    if not ctx.git:
+        return Error("Git client is not available in the workflow context.")
+
+    # 2. Get required data from context and client config
+    title = ctx.get("pr_title")
+    body = ctx.get("pr_body")
+    base = ctx.git.main_branch  # Get base branch from git client config
+    head = ctx.get("pr_head_branch")
+    is_draft = ctx.get("pr_is_draft", False)  # Default to not a draft
+
+    if not all([title, base, head]):
+        return Error(
+            "Missing required context for creating a pull request: pr_title, pr_head_branch."
+        )
+
+    # 3. Determine assignees if auto-assign is enabled
+    assignees = None
+    if ctx.github.config.auto_assign_prs:
+        try:
+            current_user = ctx.github.get_current_user()
+            assignees = [current_user]
+        except GitHubAPIError as e:
+            # Log warning but continue without assignee
+            ctx.textual.text(f"Could not get current user for auto-assign: {e}", markup="yellow")
+
+    # 4. Call the client method
+    try:
+        pr = ctx.github.create_pull_request(
+            title=title, body=body, base=base, head=head, draft=is_draft, assignees=assignees
+        )
+        ctx.textual.mount(
+            Panel(
+                text=msg.GitHub.PR_CREATED.format(number=pr["number"], url=pr["url"]),
+                panel_type="success"
+            )
+        )
+
+        # 4. Return Success with PR info
+        return Success(
+            "Pull request created successfully.",
+            metadata={"pr_number": pr["number"], "pr_url": pr["url"]},
+        )
+    except GitHubAPIError as e:
+        return Error(f"Failed to create pull request: {e}")
+    except Exception as e:
+        return Error(
+            f"An unexpected error occurred while creating the pull request: {e}"
+        )

titan_plugin_github/steps/github_prompt_steps.py

@@ -0,0 +1,171 @@
+# plugins/titan-plugin-github/titan_plugin_github/steps/prompt_steps.py
+from titan_cli.engine.context import WorkflowContext
+from titan_cli.engine.results import WorkflowResult, Success, Error, Skip
+from ..messages import msg
+
+
+def prompt_for_pr_title_step(ctx: WorkflowContext) -> WorkflowResult:
+    """
+    Interactively prompts the user for a Pull Request title.
+    Skips if pr_title already exists.
+
+    Requires:
+        ctx.textual: Textual UI components.
+
+    Outputs (saved to ctx.data):
+        pr_title (str): The title entered by the user.
+
+    Returns:
+        Success: If the title was captured successfully.
+        Error: If the user cancels or the title is empty.
+        Skip: If pr_title already exists.
+    """
+    if not ctx.textual:
+        return Error("Textual UI context is not available for this step.")
+
+    # Skip if title already exists (e.g., from AI generation)
+    if ctx.get("pr_title"):
+        return Skip("PR title already provided, skipping manual prompt.")
+
+    try:
+        title = ctx.textual.ask_text(msg.Prompts.ENTER_PR_TITLE)
+        if not title:
+            return Error("PR title cannot be empty.")
+        return Success("PR title captured", metadata={"pr_title": title})
+    except (KeyboardInterrupt, EOFError):
+        return Error("User cancelled.")
+    except Exception as e:
+        return Error(f"Failed to prompt for PR title: {e}", exception=e)
+
+
+def prompt_for_pr_body_step(ctx: WorkflowContext) -> WorkflowResult:
+    """
+    Interactively prompts the user for a Pull Request body.
+    Skips if pr_body already exists.
+
+    Requires:
+        ctx.textual: Textual UI components.
+
+    Outputs (saved to ctx.data):
+        pr_body (str): The body/description entered by the user.
+
+    Returns:
+        Success: If the body was captured successfully.
+        Error: If the user cancels.
+        Skip: If pr_body already exists.
+    """
+    if not ctx.textual:
+        return Error("Textual UI context is not available for this step.")
+
+    # Skip if body already exists (e.g., from AI generation)
+    if ctx.get("pr_body"):
+        return Skip("PR body already provided, skipping manual prompt.")
+
+    try:
+        body = ctx.textual.ask_multiline(msg.Prompts.ENTER_PR_BODY, default="")
+        # Body can be empty
+        return Success("PR body captured", metadata={"pr_body": body})
+    except (KeyboardInterrupt, EOFError):
+        return Error("User cancelled.")
+    except Exception as e:
+        return Error(f"Failed to prompt for PR body: {e}", exception=e)
+
+
+def prompt_for_issue_body_step(ctx: WorkflowContext) -> WorkflowResult:
+    """
+    Interactively prompts the user for a GitHub issue body.
+    Skips if issue_body already exists.
+
+    Requires:
+        ctx.textual: Textual UI components.
+
+    Outputs (saved to ctx.data):
+        issue_body (str): The body/description entered by the user.
+
+    Returns:
+        Success: If the body was captured successfully.
+        Error: If the user cancels.
+        Skip: If issue_body already exists.
+    """
+    if not ctx.textual:
+        return Error("Textual UI context is not available for this step.")
+
+    # Skip if body already exists (e.g., from AI generation)
+    if ctx.get("issue_body"):
+        return Skip("Issue body already provided, skipping manual prompt.")
+
+    try:
+        body = ctx.textual.ask_multiline(msg.Prompts.ENTER_ISSUE_BODY, default="")
+        # Body can be empty
+        return Success("Issue body captured", metadata={"issue_body": body})
+    except (KeyboardInterrupt, EOFError):
+        return Error("User cancelled.")
+    except Exception as e:
+        return Error(f"Failed to prompt for issue body: {e}", exception=e)
+
+
+def prompt_for_self_assign_step(ctx: WorkflowContext) -> WorkflowResult:
+    """
+    Asks the user if they want to assign the issue to themselves.
+    """
+    if not ctx.textual:
+        return Error("Textual UI context is not available for this step.")
+
+    if not ctx.github:
+        return Error("GitHub client not available")
+
+    try:
+        if ctx.textual.ask_confirm(msg.Prompts.ASSIGN_TO_SELF, default=True):
+            current_user = ctx.github.get_current_user()
+            assignees = ctx.get("assignees", [])
+            if current_user not in assignees:
+                assignees.append(current_user)
+            ctx.set("assignees", assignees)
+            return Success(f"Issue will be assigned to {current_user}")
+        return Success("Issue will not be assigned to current user")
+    except (KeyboardInterrupt, EOFError):
+        return Error("User cancelled.")
+    except Exception as e:
+        return Error(f"Failed to prompt for self-assign: {e}", exception=e)
+
+
+def prompt_for_labels_step(ctx: WorkflowContext) -> WorkflowResult:
+    """
+    Prompts the user to select labels for the issue.
+    """
+    if not ctx.textual:
+        return Error("Textual UI context is not available for this step.")
+
+    if not ctx.github:
+        return Error("GitHub client not available")
+
+    try:
+        available_labels = ctx.github.list_labels()
+        if not available_labels:
+            return Skip("No labels found in the repository.")
+
+        # Show available labels
+        ctx.textual.text(f"Available labels: {', '.join(available_labels)}", markup="dim")
+
+        # Get default labels as comma-separated string
+        existing_labels = ctx.get("labels", [])
+        default_value = ",".join(existing_labels) if existing_labels else ""
+
+        # TODO: Implement multi-select in Textual - for now use comma-separated input
+        labels_input = ctx.textual.ask_text(
+            f"{msg.Prompts.SELECT_LABELS} (comma-separated)",
+            default=default_value
+        )
+
+        # Parse comma-separated labels
+        if labels_input:
+            selected_labels = [label.strip() for label in labels_input.split(",") if label.strip()]
+        else:
+            selected_labels = []
+
+        ctx.set("labels", selected_labels)
+        return Success("Labels selected")
+    except (KeyboardInterrupt, EOFError):
+        return Error("User cancelled.")
+    except Exception as e:
+        return Error(f"Failed to prompt for labels: {e}", exception=e)

titan_plugin_github/steps/issue_steps.py

@@ -0,0 +1,143 @@
+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
+
+def ai_suggest_issue_title_and_body_step(ctx: WorkflowContext) -> WorkflowResult:
+    """
+    Use AI to suggest a title and description for a GitHub issue.
+    Auto-categorizes and selects the appropriate template.
+    """
+    if not ctx.textual:
+        return Error("Textual UI context is not available for this step.")
+
+    if not ctx.ai:
+        return Skip("AI client not available")
+
+    issue_body_prompt = ctx.get("issue_body")
+    if not issue_body_prompt:
+        return Error("issue_body not found in context")
+
+    ctx.textual.text("Using AI to categorize and generate issue...", markup="cyan")
+
+    try:
+        # Get available labels from repository for smart mapping
+        available_labels = None
+        if ctx.github:
+            try:
+                available_labels = ctx.github.list_labels()
+            except Exception:
+                # If we can't get labels, continue without filtering
+                pass
+
+        # 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)
+
+        with ctx.textual.loading("Generating issue with AI..."):
+            result = issue_generator.generate_issue(issue_body_prompt, available_labels=available_labels)
+
+        # Show category detected
+        category = result["category"]
+        template_used = result.get("template_used", False)
+
+        ctx.textual.mount(
+            Panel(
+                text=f"Category detected: {category}",
+                panel_type="success"
+            )
+        )
+
+        if template_used:
+            ctx.textual.text(f"Using template: {category}.md", markup="cyan")
+        else:
+            ctx.textual.text(f"No template found for {category}, using default structure", markup="yellow")
+
+        ctx.set("issue_title", result["title"])
+        ctx.set("issue_body", result["body"])
+        ctx.set("issue_category", category)
+        ctx.set("labels", result["labels"])
+
+        return Success(f"AI-generated issue ({category}) created successfully")
+    except Exception as e:
+        return Error(f"Failed to generate issue: {e}")
+
+
+def create_issue_steps(ctx: WorkflowContext) -> WorkflowResult:
+    """
+    Create a new GitHub issue.
+    """
+    if not ctx.textual:
+        return Error("Textual UI context is not available for this step.")
+
+    if not ctx.github:
+        return Error("GitHub client not available")
+
+    issue_title = ctx.get("issue_title")
+    issue_body = ctx.get("issue_body")
+    assignees = ctx.get("assignees", [])
+    labels = ctx.get("labels", [])
+
+    # Safely parse string representations to lists
+    if isinstance(assignees, str):
+        try:
+            assignees = ast.literal_eval(assignees)
+        except (ValueError, SyntaxError):
+            assignees = []
+
+    if isinstance(labels, str):
+        try:
+            labels = ast.literal_eval(labels)
+        except (ValueError, SyntaxError):
+            labels = []
+
+    # Ensure they are lists
+    if not isinstance(assignees, list):
+        assignees = []
+    if not isinstance(labels, list):
+        labels = []
+
+    if not issue_title:
+        return Error("issue_title not found in context")
+
+    if not issue_body:
+        return Error("issue_body not found in context")
+
+    # Filter labels to only those that exist in the repository
+    if labels and ctx.github:
+        try:
+            available_labels = ctx.github.list_labels()
+            # Filter labels to only include those that exist (case-insensitive)
+            filtered_labels = [
+                label for label in labels
+                if label.lower() in [av_label.lower() for av_label in available_labels]
+            ]
+            labels = filtered_labels
+        except Exception:
+            # If we can't validate labels, continue with all labels anyway
+            pass
+
+    try:
+        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"
+            )
+        )
+        return Success(
+            f"Successfully created issue #{issue.number}",
+            metadata={"issue": issue}
+        )
+    except Exception as e:
+        return Error(f"Failed to create issue: {e}")

titan_plugin_github/steps/preview_step.py

@@ -0,0 +1,40 @@
+from titan_cli.engine.context import WorkflowContext
+from titan_cli.engine.results import WorkflowResult, Success, Error
+
+def preview_and_confirm_issue_step(ctx: WorkflowContext) -> WorkflowResult:
+    """
+    Show a preview of the AI-generated issue and ask for confirmation.
+    """
+    if not ctx.textual:
+        return Error("Textual UI context is not available for this step.")
+
+    issue_title = ctx.get("issue_title")
+    issue_body = ctx.get("issue_body")
+
+    if not issue_title or not issue_body:
+        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.text("")  # spacing
+
+    # Show title
+    ctx.textual.text("Title:", markup="bold")
+    ctx.textual.text(f"  {issue_title}", markup="cyan")
+    ctx.textual.text("")  # spacing
+
+    # Show description
+    ctx.textual.text("Description:", markup="bold")
+    # Render markdown in a scrollable container
+    ctx.textual.markdown(issue_body)
+
+    ctx.textual.text("")  # spacing
+
+    try:
+        if not ctx.textual.ask_confirm("Use this AI-generated issue?", default=True):
+            return Error("User rejected AI-generated issue")
+    except (KeyboardInterrupt, EOFError):
+        return Error("User cancelled operation")
+
+    return Success("User confirmed AI-generated issue")

titan_plugin_github/utils.py

@@ -0,0 +1,82 @@
+# plugins/titan-plugin-github/titan_plugin_github/utils.py
+"""Utility functions for GitHub plugin."""
+
+import re
+from dataclasses import dataclass
+
+
+# Default limits for diff processing
+DEFAULT_MAX_DIFF_SIZE = 8000  # Characters
+DEFAULT_MAX_FILES_IN_DIFF = 50
+DEFAULT_MAX_COMMITS_TO_ANALYZE = 15
+
+
+@dataclass
+class PRSizeEstimation:
+    """
+    PR size estimation with character limits.
+
+    Attributes:
+        pr_size: Size category (small, medium, large, very large)
+        max_chars: Maximum characters for PR description
+        files_changed: Number of files changed
+        diff_lines: Number of lines in diff
+    """
+    pr_size: str
+    max_chars: int
+    files_changed: int
+    diff_lines: int
+
+
+def calculate_pr_size(diff: str) -> PRSizeEstimation:
+    """
+    Analyzes a git diff to estimate PR size and suggest character limits.
+
+    This is the single source of truth for PR size calculation.
+    Both PRAgent and workflow steps use this function.
+
+    Args:
+        diff: The full text of the git diff
+
+    Returns:
+        PRSizeEstimation with size category and character limits
+
+    Examples:
+        >>> diff = "diff --git a/file.py b/file.py\\n..."
+        >>> estimation = calculate_pr_size(diff)
+        >>> print(estimation.pr_size)
+        'small'
+    """
+    diff_lines = len(diff.split('\n'))
+
+    # Count files changed (count file headers in diff)
+    file_pattern = r'^diff --git'
+    files_changed = len(re.findall(file_pattern, diff, re.MULTILINE))
+
+    # Dynamic character limit based on PR size
+    if files_changed <= 3 and diff_lines < 100:
+        # Small PR: bug fix, doc update, small feature
+        max_chars = 800
+        pr_size = "small"
+    elif files_changed <= 10 and diff_lines < 500:
+        # Medium PR: feature, moderate refactor
+        max_chars = 1800
+        pr_size = "medium"
+    elif files_changed <= 30 and diff_lines < 2000:
+        # Large PR: architectural changes, new modules
+        max_chars = 3000
+        pr_size = "large"
+    else:
+        # Very large PR: major refactor, breaking changes
+        max_chars = 4500
+        pr_size = "very large"
+
+    return PRSizeEstimation(
+        pr_size=pr_size,
+        max_chars=max_chars,
+        files_changed=files_changed,
+        diff_lines=diff_lines
+    )
+
+
+__all__ = ["calculate_pr_size", "PRSizeEstimation"]

titan_plugin_github/workflows/__previews__/__init__.py

@@ -0,0 +1 @@
+# Workflow previews for GitHub plugin