titan-cli 0.1.0__py3-none-any.whl

titan_plugin_git/steps/push_step.py

@@ -0,0 +1,63 @@
+# plugins/titan-plugin-git/titan_plugin_git/steps/push_step.py
+from titan_cli.engine import WorkflowContext, WorkflowResult, Success, Error
+from titan_plugin_git.exceptions import GitCommandError
+from titan_plugin_git.messages import msg
+from titan_cli.ui.tui.widgets import Panel
+
+def create_git_push_step(ctx: WorkflowContext) -> WorkflowResult:
+    """
+    Pushes changes to a remote repository.
+
+    Requires (from ctx.data):
+        remote (str, optional): The name of the remote to push to. Defaults to the client's default remote.
+        branch (str, optional): The name of the branch to push. Defaults to the current branch.
+        set_upstream (bool, optional): Whether to set the upstream tracking branch. Defaults to False.
+
+    Requires:
+        ctx.git: An initialized GitClient.
+
+    Outputs (saved to ctx.data):
+        pr_head_branch (str): The name of the branch that was pushed.
+
+    Returns:
+        Success: If the push was successful.
+        Error: If the push operation fails.
+    """
+    if not ctx.textual:
+        return Error("Textual UI context is not available for this step.")
+
+    if not ctx.git:
+        return Error(msg.Steps.Push.GIT_CLIENT_NOT_AVAILABLE)
+
+    # Get params from context
+    remote = ctx.get('remote')
+    branch = ctx.get('branch')
+    set_upstream = ctx.get('set_upstream', False)
+
+    # Use defaults from the GitClient if not provided in the context
+    remote_to_use = remote or ctx.git.default_remote
+    branch_to_use = branch or ctx.git.get_current_branch()
+
+    try:
+        # The first push of a branch should set the upstream
+        if not ctx.git.branch_exists_on_remote(branch=branch_to_use, remote=remote_to_use):
+            set_upstream = True
+
+        ctx.git.push(remote=remote_to_use, branch=branch_to_use, set_upstream=set_upstream)
+
+        # Show success panel
+        ctx.textual.mount(
+            Panel(
+                text=f"Pushed to {remote_to_use}/{branch_to_use}",
+                panel_type="success"
+            )
+        )
+
+        return Success(
+            message=msg.Git.PUSH_SUCCESS.format(remote=remote_to_use, branch=branch_to_use),
+            metadata={"pr_head_branch": branch_to_use}
+        )
+    except GitCommandError as e:
+        return Error(msg.Steps.Push.PUSH_FAILED.format(e=e))
+    except Exception as e:
+        return Error(msg.Git.UNEXPECTED_ERROR.format(e=e))

titan_plugin_git/steps/status_step.py

@@ -0,0 +1,59 @@
+# plugins/titan-plugin-git/titan_plugin_git/steps/status_step.py
+from titan_cli.engine import (
+    WorkflowContext,
+    WorkflowResult,
+    Success,
+    Error
+)
+from titan_cli.messages import msg as global_msg
+from ..messages import msg
+from titan_cli.ui.tui.widgets import Panel
+
+def get_git_status_step(ctx: WorkflowContext) -> WorkflowResult:
+    """
+    Retrieves the current git status and saves it to the context.
+
+    Requires:
+        ctx.git: An initialized GitClient.
+
+    Outputs (saved to ctx.data):
+        git_status (GitStatus): The full git status object, which includes the `is_clean` flag.
+
+    Returns:
+        Success: If the status was retrieved successfully.
+        Error: If the GitClient is not available or the git command fails.
+    """
+    if not ctx.git:
+        return Error(msg.Steps.Status.GIT_CLIENT_NOT_AVAILABLE)
+
+    try:
+        status = ctx.git.get_status()
+
+        if not ctx.textual:
+            return Error("Textual UI context is not available for this step.")
+
+        # If there are uncommitted changes, show warning panel
+        if not status.is_clean:
+            ctx.textual.mount(
+                Panel(
+                    text=global_msg.Workflow.UNCOMMITTED_CHANGES_WARNING,
+                    panel_type="warning"
+                )
+            )
+            message = msg.Steps.Status.STATUS_RETRIEVED_WITH_UNCOMMITTED
+        else:
+            # Show success panel for clean working directory
+            ctx.textual.mount(
+                Panel(
+                    text=msg.Steps.Status.WORKING_DIRECTORY_IS_CLEAN,
+                    panel_type="success"
+                )
+            )
+            message = msg.Steps.Status.WORKING_DIRECTORY_IS_CLEAN
+
+        return Success(
+            message=message,
+            metadata={"git_status": status}
+        )
+    except Exception as e:
+        return Error(msg.Steps.Status.FAILED_TO_GET_STATUS.format(e=e))

titan_plugin_git/workflows/__previews__/__init__.py

@@ -0,0 +1 @@
+"""Workflow previews for git plugin."""

titan_plugin_git/workflows/__previews__/commit_ai_preview.py

@@ -0,0 +1,124 @@
+#!/usr/bin/env python3
+"""
+Commit with AI Workflow Preview
+
+Preview the commit-ai workflow by executing real steps with mocked data.
+Run: titan preview workflow commit-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,
+    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_commit_ai_mock_context() -> WorkflowContext:
+    """
+    Create mock context specifically for commit-ai workflow.
+
+    Customizes mock data to simulate the commit-ai workflow scenario:
+    - Git status with uncommitted changes
+    - AI generates commit message
+    - Commit is created and pushed
+
+    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/improve-ux"
+    git.main_branch = "master"
+    git.default_remote = "origin"
+
+    ai = MockAIClient()
+
+    secrets = MockSecretManager()
+
+    # Build context
+    ctx = WorkflowContext(
+        secrets=secrets,
+        ui=ui,
+        views=views
+    )
+
+    # Inject mocked clients
+    ctx.git = git
+    ctx.ai = ai
+
+    return ctx
+
+
+def preview_workflow():
+    """
+    Preview the commit-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("Commit with AI - PREVIEW")
+    text.subtitle("(Executing real steps with mocked data)")
+    spacer.line()
+
+    # Create workflow-specific mock context
+    ctx = create_commit_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
+
+    # Execute steps in order (same as workflow YAML)
+    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),
+    ]
+
+    text.info("Executing workflow...")
+    spacer.small()
+
+    # Inject workflow metadata (like the real executor does)
+    ctx.workflow_name = "commit-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 operations were performed)")
+
+
+if __name__ == "__main__":
+    preview_workflow()

titan_plugin_git/workflows/commit-ai.yaml

@@ -0,0 +1,28 @@
+name: "Commit with AI"
+description: "Create a commit with AI-generated message"
+
+hooks:
+  - before_commit  # Hook for linting/testing
+
+steps:
+  - hook: before_commit  # This is where injected steps will run
+
+  - id: git_status
+    name: "Check Git Status"
+    plugin: git
+    step: get_status
+
+  - id: ai_commit_message
+    name: "AI Commit Message"
+    plugin: git
+    step: ai_generate_commit_message
+
+  - id: create_commit
+    name: "Create Commit"
+    plugin: git
+    step: create_commit
+  
+  - id: push
+    name: "Push changes to remote"
+    plugin: git
+    step: push

titan_plugin_github/__init__.py

@@ -0,0 +1,11 @@
+# plugins/titan-plugin-github/titan_plugin_github/__init__.py
+"""
+Titan GitHub Plugin
+
+Provides GitHub integration for pull requests, issues, and more.
+"""
+
+from .plugin import GitHubPlugin
+
+__version__ = "0.1.0"
+__all__ = ["GitHubPlugin"]

titan_plugin_github/agents/__init__.py

@@ -0,0 +1,6 @@
+# plugins/titan-plugin-github/titan_plugin_github/agents/__init__.py
+"""AI agents for GitHub plugin."""
+
+from .pr_agent import PRAgent, PRAnalysis
+
+__all__ = ["PRAgent", "PRAnalysis"]

titan_plugin_github/agents/config_loader.py

@@ -0,0 +1,130 @@
+# plugins/titan-plugin-github/titan_plugin_github/agents/config_loader.py
+"""Configuration loader for PR Agent."""
+
+import tomli
+from pathlib import Path
+from typing import Optional, Dict, Any
+from pydantic import BaseModel, Field
+
+try:
+    # Python 3.9+
+    from importlib.resources import files
+except ImportError:
+    # Python 3.7-3.8 fallback
+    from importlib_resources import files
+
+# Import default limits from plugin utils
+from ..utils import (
+    DEFAULT_MAX_DIFF_SIZE,
+    DEFAULT_MAX_FILES_IN_DIFF,
+    DEFAULT_MAX_COMMITS_TO_ANALYZE
+)
+
+
+class PRAgentConfig(BaseModel):
+    """PR 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
+    pr_system_prompt: str = Field("", description="System prompt for PR generation")
+    commit_system_prompt: str = Field("", description="System prompt for commit messages")
+    architecture_system_prompt: str = Field("", description="System prompt for architecture review")
+
+    # Diff analysis limits
+    max_diff_size: int = Field(DEFAULT_MAX_DIFF_SIZE, ge=0, description="Maximum diff size to analyze")
+    max_files_in_diff: int = Field(DEFAULT_MAX_FILES_IN_DIFF, ge=1, description="Maximum files in diff")
+    max_commits_to_analyze: int = Field(DEFAULT_MAX_COMMITS_TO_ANALYZE, ge=1, description="Maximum commits to analyze")
+
+    # Features
+    enable_template_detection: bool = Field(True, description="Enable PR template detection")
+    enable_dynamic_sizing: bool = Field(True, description="Enable dynamic PR sizing")
+    enable_user_confirmation: bool = Field(True, description="Enable user confirmation")
+    enable_fallback_prompts: bool = Field(True, description="Enable fallback prompts")
+    enable_debug_output: bool = Field(False, description="Enable debug output")
+
+    # Raw config for custom access
+    raw: Dict[str, Any] = Field(default_factory=dict, description="Raw TOML data")
+
+
+def load_agent_config(
+    agent_name: str = "pr_agent",
+    config_dir: Optional[Path] = None
+) -> PRAgentConfig:
+    """
+    Load agent configuration from TOML file.
+
+    Args:
+        agent_name: Name of the agent (e.g., "pr_agent")
+        config_dir: Optional custom config directory
+
+    Returns:
+        PRAgentConfig 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
+        # Works with both development and installed (pip/pipx) environments
+        config_files = files("titan_plugin_github.config")
+        config_file = config_files.joinpath(f"{agent_name}.toml")
+
+        # Convert Traversable to Path
+        # In Python 3.9+, this handles both filesystem and zip-based resources
+        if hasattr(config_file, "__fspath__"):
+            config_path = Path(config_file.__fspath__())
+        else:
+            # Fallback for older Python or non-filesystem resources
+            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", {})
+
+    # Build PRAgentConfig
+    return PRAgentConfig(
+        name=agent_meta.get("name", agent_name),
+        description=agent_meta.get("description", ""),
+        version=agent_meta.get("version", "1.0.0"),
+        # Prompts
+        pr_system_prompt=prompts.get("pr_description", {}).get("system", ""),
+        commit_system_prompt=prompts.get("commit_message", {}).get("system", ""),
+        architecture_system_prompt=prompts.get("architecture_review", {}).get("system", ""),
+        # Limits (use defaults from utils)
+        max_diff_size=limits.get("max_diff_size", DEFAULT_MAX_DIFF_SIZE),
+        max_files_in_diff=limits.get("max_files_in_diff", DEFAULT_MAX_FILES_IN_DIFF),
+        max_commits_to_analyze=limits.get("max_commits_to_analyze", DEFAULT_MAX_COMMITS_TO_ANALYZE),
+        # Features
+        enable_template_detection=features.get("enable_template_detection", True),
+        enable_dynamic_sizing=features.get("enable_dynamic_sizing", True),
+        enable_user_confirmation=features.get("enable_user_confirmation", True),
+        enable_fallback_prompts=features.get("enable_fallback_prompts", True),
+        enable_debug_output=features.get("enable_debug_output", False),
+        # Raw for custom access
+        raw=data
+    )