titan-cli 0.1.0__py3-none-any.whl

titan_plugin_github/workflows/__previews__/create_pr_ai_preview.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+"""
+Create PR with AI Workflow Preview
+
+Preview the create-pr-ai workflow by executing real steps with mocked data.
+Run: titan preview workflow create-pr-ai
+"""
+
+from titan_cli.ui.components.typography import TextRenderer
+from titan_cli.ui.components.spacer import SpacerRenderer
+from titan_cli.engine.mock_context import (
+    MockGitClient,
+    MockAIClient,
+    MockGitHubClient,
+    MockSecretManager,
+)
+from titan_cli.engine import WorkflowContext
+from titan_cli.engine.ui_container import UIComponents
+from titan_cli.engine.views_container import UIViews
+from titan_cli.engine.results import Success, Error, Skip
+
+
+def create_create_pr_ai_mock_context() -> WorkflowContext:
+    """
+    Create mock context specifically for create-pr-ai workflow.
+
+    Customizes mock data to simulate the create-pr-ai workflow scenario:
+    - Git status with uncommitted changes
+    - AI generates commit message and PR description
+    - GitHub creates PR on feature branch
+
+    Pre-populates context data to ensure all steps execute successfully
+    and display their full UI in the preview.
+    """
+    # Create UI components
+    ui = UIComponents.create()
+    views = UIViews.create(ui)
+
+    # Override prompts to auto-confirm (non-interactive preview)
+    views.prompts.ask_confirm = lambda question, default=True: True
+
+    # Create mock clients with workflow-specific data
+    git = MockGitClient()
+    git.current_branch = "feat/workflow-preview"
+    git.main_branch = "master"
+    git.default_remote = "origin"
+
+    ai = MockAIClient()
+
+    github = MockGitHubClient()
+    github.repo_owner = "mockuser"
+    github.repo_name = "titan-cli"
+
+    secrets = MockSecretManager()
+
+    # Build context
+    ctx = WorkflowContext(
+        secrets=secrets,
+        ui=ui,
+        views=views
+    )
+
+    # Inject mocked clients
+    ctx.git = git
+    ctx.ai = ai
+    ctx.github = github
+
+    # Pre-populate initial data for complete workflow execution
+    # This simulates data that would come from command-line or earlier setup
+    ctx.set("base_branch", "master")
+    ctx.set("draft", False)
+
+    return ctx
+
+
+def preview_workflow():
+    """
+    Preview the create-pr-ai workflow by executing real steps with mocked context.
+
+    This ensures the preview always matches the real workflow execution.
+    """
+    text = TextRenderer()
+    spacer = SpacerRenderer()
+
+    # Header
+    text.title("Create Pull Request with AI - PREVIEW")
+    text.subtitle("(Executing real steps with mocked data)")
+    spacer.line()
+
+    # Create workflow-specific mock context
+    ctx = create_create_pr_ai_mock_context()
+
+    # Import steps
+    from titan_plugin_git.steps.status_step import get_git_status_step
+    from titan_plugin_git.steps.ai_commit_message_step import ai_generate_commit_message
+    from titan_plugin_git.steps.commit_step import create_git_commit_step
+    from titan_plugin_git.steps.push_step import create_git_push_step
+    from titan_plugin_github.steps.ai_pr_step import ai_suggest_pr_description_step
+    from titan_plugin_github.steps.prompt_steps import prompt_for_pr_title_step, prompt_for_pr_body_step
+
+    # Execute steps in order
+    steps = [
+        ("git_status", get_git_status_step),
+        ("ai_commit_message", ai_generate_commit_message),
+        ("create_commit", create_git_commit_step),
+        ("push", create_git_push_step),
+        ("ai_pr_description", ai_suggest_pr_description_step),
+        ("prompt_pr_title", prompt_for_pr_title_step),
+        ("prompt_pr_body", prompt_for_pr_body_step),
+    ]
+
+    text.info("Executing workflow...")
+    spacer.small()
+
+    # Inject workflow metadata (like the real executor does)
+    ctx.workflow_name = "create-pr-ai"
+    ctx.total_steps = len(steps)
+
+    for i, (step_name, step_fn) in enumerate(steps, 1):
+        # Inject current step number (like the real executor does)
+        ctx.current_step = i
+
+        # Execute the step - it will handle all its own UI
+        result = step_fn(ctx)
+
+        # Merge metadata into context (like the real executor does)
+        if isinstance(result, (Success, Skip)) and result.metadata:
+            ctx.data.update(result.metadata)
+
+        # Only handle errors (steps handle their own success/skip UI)
+        if isinstance(result, Error):
+            text.error(f"Step '{step_name}' failed: {result.message}")
+            break
+
+    spacer.line()
+    text.info("(This was a preview - no actual git/GitHub operations were performed)")
+
+
+if __name__ == "__main__":
+    preview_workflow()

titan_plugin_github/workflows/create-issue-ai.yaml

@@ -0,0 +1,32 @@
+name: "Create GitHub Issue (AI-Powered)"
+description: "Create a GitHub issue with AI-generated description and auto-categorization"
+params:
+  assignees: []
+steps:
+  - id: prompt_for_issue_body
+    name: "Prompt for Issue Body"
+    plugin: github
+    step: prompt_for_issue_body_step
+
+  - id: ai_suggest_issue
+    name: "Categorize and Generate Issue"
+    plugin: github
+    step: ai_suggest_issue_title_and_body
+
+  - id: preview_and_confirm_issue
+    name: "Preview and Confirm Issue"
+    plugin: github
+    step: preview_and_confirm_issue
+
+  - id: prompt_for_self_assign
+    name: "Prompt for Self Assign"
+    plugin: github
+    step: prompt_for_self_assign
+
+  - id: create_issue
+    name: "Create Issue"
+    plugin: github
+    step: create_issue
+    params:
+      assignees: "${assignees}"
+      labels: "${labels}"

titan_plugin_github/workflows/create-pr-ai.yaml

@@ -0,0 +1,49 @@
+name: "Create Pull Request with AI"
+description: "AI-powered PR creation with intelligent analysis and suggestions"
+
+params:
+  draft: false
+
+hooks:
+  - before_push
+  - after_pr
+
+steps:
+  # Use the commit-ai workflow (respects project override for linting/testing)
+  - id: commit_changes
+    name: "Commit changes with AI"
+    workflow: "commit-ai"
+
+  - id: get_head_branch
+    name: "Get Head Branch"
+    plugin: git
+    step: get_current_branch
+
+  # AI generates PR title and description from branch commits
+  - id: ai_pr_description
+    name: "AI PR Description"
+    plugin: github
+    step: ai_suggest_pr_description
+
+  - 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
+    step: create_pr
+    requires:
+      - pr_title
+      - pr_head_branch
+
+  - hook: after_pr

titan_plugin_jira/__init__.py

@@ -0,0 +1,8 @@
+# plugins/titan-plugin-jira/titan_plugin_jira/__init__.py
+"""
+Titan Plugin: JIRA
+
+AI-powered JIRA integration plugin for Titan CLI.
+"""
+
+__version__ = "1.0.0"

titan_plugin_jira/agents/__init__.py

@@ -0,0 +1,6 @@
+# plugins/titan-plugin-jira/titan_plugin_jira/agents/__init__.py
+"""AI agents for JIRA automation."""
+
+from .jira_agent import JiraAgent, IssueAnalysis
+
+__all__ = ["JiraAgent", "IssueAnalysis"]

titan_plugin_jira/agents/config_loader.py

@@ -0,0 +1,154 @@
+# plugins/titan-plugin-jira/titan_plugin_jira/agents/config_loader.py
+"""Configuration loader for JIRA Agent."""
+
+import tomli
+from pathlib import Path
+from typing import Optional, Dict, Any
+from pydantic import BaseModel, Field, ConfigDict
+
+try:
+    # Python 3.9+
+    from importlib.resources import files
+except ImportError:
+    # Python 3.7-3.8 fallback
+    from importlib_resources import files
+
+
+class JiraAgentConfig(BaseModel):
+    """JIRA Agent configuration loaded from TOML."""
+
+    name: str = Field(..., description="Agent name")
+    description: str = Field("", description="Agent description")
+    version: str = Field("1.0.0", description="Agent version")
+
+    # Prompts
+    requirements_system_prompt: str = Field("", description="System prompt for requirements analysis")
+    description_enhancement_prompt: str = Field("", description="System prompt for description enhancement")
+    comment_generation_prompt: str = Field("", description="System prompt for comment generation")
+    subtask_suggestion_prompt: str = Field("", description="System prompt for subtask suggestion")
+    smart_labeling_prompt: str = Field("", description="System prompt for smart labeling")
+
+    # Limits
+    max_description_length: int = Field(5000, ge=0, description="Maximum description length")
+    max_subtasks: int = Field(10, ge=1, description="Maximum subtasks to suggest")
+    max_comments_to_analyze: int = Field(20, ge=1, description="Maximum comments to analyze")
+    max_linked_issues: int = Field(15, ge=1, description="Maximum linked issues to consider")
+
+    # AI Parameters
+    temperature: float = Field(0.7, ge=0.0, le=2.0, description="AI temperature for generation")
+    max_tokens: int = Field(2000, ge=1, description="Maximum tokens per AI request")
+
+    # Features (Active)
+    enable_requirement_extraction: bool = Field(True, description="Enable requirement extraction")
+    enable_subtasks: bool = Field(True, description="Enable subtask suggestion")
+    enable_risk_analysis: bool = Field(True, description="Enable risk analysis")
+    enable_dependency_detection: bool = Field(True, description="Enable dependency detection")
+    enable_acceptance_criteria: bool = Field(True, description="Enable acceptance criteria generation")
+    enable_debug_output: bool = Field(False, description="Enable debug output (logs AI responses)")
+
+    # Features (Planned - Not Yet Implemented)
+    # These flags are reserved for future functionality
+    # TODO: Implement Gherkin test generation (PR #74 comment: remove unused flags)
+    # enable_gherkin_tests: bool = Field(False, description="Enable Gherkin/BDD test scenario generation")
+    # TODO: Implement strict label classification
+    # enable_strict_labeling: bool = Field(False, description="Enable strict label classification")
+    # TODO: Implement token optimization strategies
+    # enable_token_saving: bool = Field(False, description="Enable token optimization strategies")
+
+    # Formatting
+    template: str = Field("", description="Optional Jinja2 template filename for formatting output")
+
+    # Raw config for custom access
+    raw: Dict[str, Any] = Field(default_factory=dict, description="Raw TOML data")
+
+    model_config = ConfigDict(frozen=False)  # Allow mutation for caching
+
+
+def load_agent_config(
+    agent_name: str = "jira_agent",
+    config_dir: Optional[Path] = None
+) -> JiraAgentConfig:
+    """
+    Load agent configuration from TOML file.
+
+    Args:
+        agent_name: Name of the agent (e.g., "jira_agent")
+        config_dir: Optional custom config directory
+
+    Returns:
+        JiraAgentConfig instance
+
+    Raises:
+        FileNotFoundError: If config file doesn't exist
+        ValueError: If config is invalid
+    """
+    # Determine config file path
+    if config_dir:
+        config_path = config_dir / f"{agent_name}.toml"
+    else:
+        # Use importlib.resources for robust path resolution
+        config_files = files("titan_plugin_jira.config")
+        config_file = config_files.joinpath(f"{agent_name}.toml")
+
+        # Convert Traversable to Path
+        if hasattr(config_file, "__fspath__"):
+            config_path = Path(config_file.__fspath__())
+        else:
+            config_path = Path(str(config_file))
+
+    if not config_path.exists():
+        raise FileNotFoundError(f"Agent config not found: {config_path}")
+
+    # Load TOML
+    try:
+        with open(config_path, "rb") as f:
+            data = tomli.load(f)
+    except tomli.TOMLDecodeError as e:
+        raise ValueError(f"Invalid TOML in {config_path}: {e}")
+    except Exception as e:
+        raise ValueError(f"Failed to read config {config_path}: {e}")
+
+    # Validate config structure
+    if "agent" not in data:
+        raise ValueError(f"Missing [agent] section in {config_path}")
+
+    # Extract sections
+    agent_meta = data.get("agent", {})
+    prompts = data.get("agent", {}).get("prompts", {})
+    limits = data.get("agent", {}).get("limits", {})
+    features = data.get("agent", {}).get("features", {})
+    formatting = data.get("agent", {}).get("formatting", {})
+
+    # Build JiraAgentConfig
+    return JiraAgentConfig(
+        name=agent_meta.get("name", agent_name),
+        description=agent_meta.get("description", ""),
+        version=agent_meta.get("version", "1.0.0"),
+        # Prompts
+        requirements_system_prompt=prompts.get("requirements_analysis", {}).get("system", ""),
+        description_enhancement_prompt=prompts.get("description_enhancement", {}).get("system", ""),
+        comment_generation_prompt=prompts.get("comment_generation", {}).get("system", ""),
+        subtask_suggestion_prompt=prompts.get("subtask_suggestion", {}).get("system", ""),
+        smart_labeling_prompt=prompts.get("smart_labeling", {}).get("system", ""),
+        # Limits
+        max_description_length=limits.get("max_description_length", 5000),
+        max_subtasks=limits.get("max_subtasks", 10),
+        max_comments_to_analyze=limits.get("max_comments_to_analyze", 20),
+        max_linked_issues=limits.get("max_linked_issues", 15),
+        # AI Parameters
+        temperature=limits.get("temperature", agent_meta.get("temperature", 0.7)),
+        max_tokens=limits.get("max_tokens", agent_meta.get("max_tokens", 2000)),
+        # Features (Active)
+        enable_requirement_extraction=features.get("enable_requirement_extraction", True),
+        enable_subtasks=features.get("enable_subtasks", True),
+        enable_risk_analysis=features.get("enable_risk_analysis", True),
+        enable_dependency_detection=features.get("enable_dependency_detection", True),
+        enable_acceptance_criteria=features.get("enable_acceptance_criteria", True),
+        enable_debug_output=features.get("enable_debug_output", False),
+        # Note: Removed unused flags (enable_gherkin_tests, enable_strict_labeling, enable_token_saving)
+        # These will be added back when functionality is implemented
+        # Formatting
+        template=formatting.get("template", ""),
+        # Raw for custom access
+        raw=data
+    )