titan-cli 0.1.0__py3-none-any.whl

titan_cli/engine/mock_context.py

@@ -0,0 +1,176 @@
+"""
+Mock Clients for Workflow Previews
+
+Provides mock implementations of clients (Git, AI, GitHub) that can be used
+by workflow previews to execute real step functions with fake data.
+
+Each preview should create its own mock context with customized data.
+"""
+
+from typing import Optional
+from dataclasses import dataclass
+
+
+@dataclass
+class MockGitStatus:
+    """Mock git status for previews"""
+    is_clean: bool = False
+    modified_files: list = None
+    untracked_files: list = None
+    staged_files: list = None
+
+    def __post_init__(self):
+        if self.modified_files is None:
+            self.modified_files = ["cli.py", "messages.py"]
+        if self.untracked_files is None:
+            self.untracked_files = ["preview.py"]
+        if self.staged_files is None:
+            self.staged_files = []
+
+
+class MockGitClient:
+    """Mock GitClient for previews"""
+
+    def __init__(self):
+        self.main_branch = "master"
+        self.current_branch = "feat/workflow-preview"
+        self.default_remote = "origin"
+
+    def get_status(self):
+        return MockGitStatus(is_clean=False)
+
+    def get_current_branch(self) -> str:
+        return self.current_branch
+
+    def branch_exists_on_remote(self, branch: str, remote: str = "origin") -> bool:
+        # Mock: always return False to trigger set_upstream
+        return False
+
+    def get_uncommitted_diff(self) -> str:
+        return """diff --git a/cli.py b/cli.py
+index abc123..def456 100644
+--- a/cli.py
++++ b/cli.py
+@@ -1,3 +1,5 @@
++from titan_cli.preview import preview_workflow
++
+ def main():
+-    pass
++    # Added preview functionality
++    preview_workflow()"""
+
+    def get_branch_diff(self, base: str, head: str) -> str:
+        return """diff --git a/preview.py b/preview.py
+new file mode 100644
+index 0000000..abc123
+--- /dev/null
++++ b/preview.py
+@@ -0,0 +1,50 @@
++# Preview system for workflows
++def preview_workflow(name):
++    pass"""
+
+    def get_branch_commits(self, base: str, head: str) -> list[str]:
+        return [
+            "feat(workflows): add preview system",
+            "feat(ui): improve panel rendering",
+            "fix(git): handle uncommitted changes"
+        ]
+
+    def commit(self, message: str, all: bool = True) -> str:
+        return "abc1234567890"
+
+    def push(self, remote: str = "origin", branch: Optional[str] = None, set_upstream: bool = False):
+        return True
+
+
+class MockAIResponse:
+    """Mock AI response"""
+    def __init__(self, content: str):
+        self.content = content
+
+
+class MockAIClient:
+    """Mock AIClient for previews"""
+
+    def is_available(self) -> bool:
+        return True
+
+    def generate(self, messages, max_tokens: int = 1000, temperature: float = 0.7):
+        # Extract the prompt
+        prompt = messages[0].content if messages else ""
+
+        # Generate different responses based on context
+        if "commit message" in prompt.lower():
+            return MockAIResponse(
+                "feat(workflows): add preview system for workflows with mocked data"
+            )
+        elif "pull request" in prompt.lower() or "pr" in prompt.lower():
+            return MockAIResponse("""TITLE: feat(workflows): Add preview system for testing workflow UI
+
+DESCRIPTION:
+## Summary
+- Added `titan preview workflow <name>` command
+- Created mock context system for workflow previews
+- Implemented preview for create-pr-ai workflow
+
+## Type of Change
+- [x] New feature (non-breaking)
+- [ ] Bug fix
+- [ ] Breaking change
+
+## Testing
+- [x] Tested preview command with create-pr-ai
+- [x] Verified mocked data displays correctly""")
+        else:
+            return MockAIResponse("Mocked AI response")
+
+
+class MockGitHubClient:
+    """Mock GitHubClient for previews"""
+
+    def __init__(self):
+        self.repo_owner = "mockuser"
+        self.repo_name = "mock-repo"
+
+    def create_pull_request(self, title: str, body: str, head: str, base: str, draft: bool = False):
+        """Mock create PR - returns fake PR data"""
+        return {
+            "number": 123,
+            "url": "https://github.com/mockuser/mock-repo/pull/123",
+            "title": title,
+            "body": body,
+            "head": head,
+            "base": base,
+            "draft": draft
+        }
+
+
+class MockSecretManager:
+    """Mock SecretManager for previews"""
+
+    def __init__(self, project_path=None):
+        self.project_path = project_path
+
+    def get(self, key: str, default: Optional[str] = None) -> Optional[str]:
+        """Mock get secret - returns fake values"""
+        mock_secrets = {
+            "github_token": "ghp_mocktoken123",
+            "anthropic_api_key": "sk-ant-mock123",
+        }
+        return mock_secrets.get(key, default)
+
+    def set(self, key: str, value: str) -> None:
+        """Mock set secret - does nothing"""
+        pass
+
+
+# Export all mock classes for use in previews
+__all__ = [
+    "MockGitStatus",
+    "MockGitClient",
+    "MockAIResponse",
+    "MockAIClient",
+    "MockGitHubClient",
+    "MockSecretManager",
+]

titan_cli/engine/results.py

@@ -0,0 +1,91 @@
+"""
+Workflow result types for atomic steps.
+"""
+
+from typing import Any, Optional, Union
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Success:
+    """
+    Step completed successfully.
+    
+    Attributes:
+        message: Success message (optional)
+        metadata: Metadata to auto-merge into ctx.data
+    
+    Examples:
+        >>> return Success("User validated")
+        >>> return Success("PR created", metadata={"pr_number": 123})
+    """
+    message: str = ""
+    metadata: Optional[dict[str, Any]] = None
+
+@dataclass(frozen=True)
+class Error:
+    """
+    Step failed with an error.
+    
+    Attributes:
+        message: Error message (required)
+        code: Error code (default: 1)
+        exception: Original exception if available
+        recoverable: Whether error can be recovered from
+    
+    Examples:
+        >>> return Error("GitHub not available")
+        >>> return Error("API rate limit", code=429, recoverable=True)
+        >>> return Error("Connection failed", exception=exc)
+    """
+    message: str
+    code: int = 1
+    exception: Optional[Exception] = None
+    recoverable: bool = False
+
+
+@dataclass(frozen=True)
+class Skip:
+    """
+    Step was skipped (not applicable).
+
+    Use when a step doesn't need to run:
+    - Optional tool not configured
+    - Condition not met
+    - User chose to skip
+
+    Attributes:
+        message: Why the step was skipped (required)
+        metadata: Metadata to auto-merge into ctx.data
+
+    Examples:
+        >>> if not ctx.ai:
+        >>>     return Skip("AI not configured")
+        >>> return Skip("No changes detected", metadata={"clean": True})
+        >>> return Skip("PR title already provided")
+    """
+    message: str
+    metadata: Optional[dict[str, Any]] = None
+
+
+# Type alias for workflow results
+WorkflowResult = Union[Success, Error, Skip]
+
+
+# ============================================================================
+# Helper functions for type checking
+# ============================================================================
+
+def is_success(result: WorkflowResult) -> bool:
+    """Check if result is Success."""
+    return isinstance(result, Success)
+
+
+def is_error(result: WorkflowResult) -> bool:
+    """Check if result is Error."""
+    return isinstance(result, Error)
+
+
+def is_skip(result: WorkflowResult) -> bool:
+    """Check if result is Skip."""
+    return isinstance(result, Skip)

titan_cli/engine/steps/ai_assistant_step.py

@@ -0,0 +1,185 @@
+"""
+AI Code Assistant Step
+
+Generic step that launches an AI coding assistant CLI (like Claude Code)
+with context from previous workflow steps.
+
+Can be used after linting, testing, builds, or any step that produces
+errors or context that could benefit from AI assistance.
+"""
+
+import json 
+
+from titan_cli.core.workflows.models import WorkflowStepModel
+from titan_cli.engine.context import WorkflowContext
+from titan_cli.engine.results import Success, Error, Skip, WorkflowResult
+from titan_cli.external_cli.launcher import CLILauncher
+from titan_cli.external_cli.configs import CLI_REGISTRY
+from titan_cli.messages import msg
+
+
+def execute_ai_assistant_step(step: WorkflowStepModel, ctx: WorkflowContext) -> WorkflowResult:
+    """
+    Launch AI coding assistant with context from workflow.
+
+    Parameters (in step.params):
+        context_key: str - Key in ctx.data to read context from
+        prompt_template: str - Template for the prompt (use {context} placeholder)
+        ask_confirmation: bool - Whether to ask user before launching (default: True)
+        fail_on_decline: bool - If True, return Error when user declines (default: False)
+        cli_preference: str - Which CLI to use: "claude", "gemini", "auto" (default: "auto")
+
+    Example workflow usage:
+        - id: ai-help
+          plugin: core
+          step: ai_code_assistant
+          params:
+            context_key: "test_failures"
+            prompt_template: "Help me fix these test failures:\n{context}"
+            ask_confirmation: true
+            fail_on_decline: true
+          on_error: fail
+    """
+    if not ctx.textual:
+        return Error(msg.AIAssistant.UI_CONTEXT_NOT_AVAILABLE)
+
+    # Get parameters
+    context_key = step.params.get("context_key")
+    prompt_template = step.params.get("prompt_template", "{context}")
+    ask_confirmation = step.params.get("ask_confirmation", True)
+    fail_on_decline = step.params.get("fail_on_decline", False)
+    cli_preference = step.params.get("cli_preference", "auto")
+
+    # Validate cli_preference
+    VALID_CLI_PREFERENCES = {"auto", "claude", "gemini"}
+    if cli_preference not in VALID_CLI_PREFERENCES:
+        return Error(f"Invalid cli_preference: {cli_preference}. Must be one of {VALID_CLI_PREFERENCES}")
+
+    # Validate required parameters
+    if not context_key:
+        return Error(msg.AIAssistant.CONTEXT_KEY_REQUIRED)
+
+    # Get context data
+    context_data = ctx.data.get(context_key)
+    if not context_data:
+        # No context to work with - skip silently
+        return Skip(msg.AIAssistant.NO_DATA_IN_CONTEXT.format(context_key=context_key))
+
+    # Clear the context data immediately to prevent contamination of subsequent steps
+    if context_key in ctx.data:
+        del ctx.data[context_key]
+
+    # Build the prompt
+    try:
+        if isinstance(context_data, str):
+            prompt = prompt_template.format(context=context_data)
+        else:
+            # If it's not a string, convert to string representation
+            context_str = json.dumps(context_data, indent=2)
+            prompt = prompt_template.format(context=context_str)
+    except KeyError as e:
+        return Error(msg.AIAssistant.INVALID_PROMPT_TEMPLATE.format(e=e))
+    except Exception as e:
+        return Error(msg.AIAssistant.FAILED_TO_BUILD_PROMPT.format(e=e))
+
+    # Ask for confirmation if needed
+    if ask_confirmation:
+        ctx.textual.text("")  # spacing
+        should_launch = ctx.textual.ask_confirm(
+            msg.AIAssistant.CONFIRM_LAUNCH_ASSISTANT,
+            default=True
+        )
+        if not should_launch:
+            if fail_on_decline:
+                return Error(msg.AIAssistant.DECLINED_ASSISTANCE_STOPPED)
+            return Skip(msg.AIAssistant.DECLINED_ASSISTANCE_SKIPPED)
+
+    # Determine which CLI to use
+    cli_to_launch = None
+
+    preferred_clis = []
+    if cli_preference == "auto":
+        preferred_clis = list(CLI_REGISTRY.keys())
+    else:
+        preferred_clis = [cli_preference]
+    
+    available_launchers = {}
+    for cli_name in preferred_clis:
+        config = CLI_REGISTRY.get(cli_name)
+        if config:
+            launcher = CLILauncher(
+                cli_name=cli_name,
+                install_instructions=config.get("install_instructions"),
+                prompt_flag=config.get("prompt_flag")
+            )
+            if launcher.is_available():
+                available_launchers[cli_name] = launcher
+
+    if not available_launchers:
+        from titan_cli.ui.tui.widgets import Panel
+        ctx.textual.mount(Panel(msg.AIAssistant.NO_ASSISTANT_CLI_FOUND, panel_type="warning"))
+        return Skip(msg.AIAssistant.NO_ASSISTANT_CLI_FOUND)
+
+    if len(available_launchers) == 1:
+        cli_to_launch = list(available_launchers.keys())[0]
+    else:
+        # Show available CLIs with numbers
+        ctx.textual.text("")  # spacing
+        ctx.textual.text(msg.AIAssistant.SELECT_ASSISTANT_CLI, markup="bold cyan")
+
+        cli_options = list(available_launchers.keys())
+        for idx, cli_name in enumerate(cli_options, 1):
+            display_name = CLI_REGISTRY[cli_name].get("display_name", cli_name)
+            ctx.textual.text(f"  {idx}. {display_name}")
+
+        ctx.textual.text("")  # spacing
+        choice_str = ctx.textual.ask_text("Select option (or press Enter to cancel):", default="")
+
+        if not choice_str or choice_str.strip() == "":
+            return Skip(msg.AIAssistant.DECLINED_ASSISTANCE_SKIPPED)
+
+        try:
+            choice_idx = int(choice_str.strip()) - 1
+            if 0 <= choice_idx < len(cli_options):
+                cli_to_launch = cli_options[choice_idx]
+            else:
+                ctx.textual.text("Invalid option selected", markup="red")
+                return Skip(msg.AIAssistant.DECLINED_ASSISTANCE_SKIPPED)
+        except ValueError:
+            ctx.textual.text("Invalid input - must be a number", markup="red")
+            return Skip(msg.AIAssistant.DECLINED_ASSISTANCE_SKIPPED)
+
+    # Validate selection
+    if cli_to_launch not in available_launchers:
+        return Error(f"Unknown CLI to launch: {cli_to_launch}")
+
+    cli_name = CLI_REGISTRY[cli_to_launch].get("display_name", cli_to_launch)
+
+    # Launch the CLI
+    from titan_cli.ui.tui.widgets import Panel
+    ctx.textual.text("")  # spacing
+    ctx.textual.text(msg.AIAssistant.LAUNCHING_ASSISTANT.format(cli_name=cli_name), markup="cyan")
+
+    # Show prompt preview
+    prompt_preview_text = msg.AIAssistant.PROMPT_PREVIEW.format(
+        prompt_preview=f"{prompt[:100]}..." if len(prompt) > 100 else prompt
+    )
+    ctx.textual.text(prompt_preview_text, markup="dim")
+    ctx.textual.text("")  # spacing
+
+    project_root = ctx.get("project_root", ".")
+
+    # Launch CLI and suspend TUI while it runs
+    exit_code = ctx.textual.launch_external_cli(
+        cli_name=cli_to_launch,
+        prompt=prompt,
+        cwd=project_root
+    )
+
+    ctx.textual.text("")  # spacing
+    ctx.textual.mount(Panel(msg.AIAssistant.BACK_IN_TITAN, panel_type="success"))
+
+    if exit_code != 0:
+        return Error(msg.AIAssistant.ASSISTANT_EXITED_WITH_CODE.format(cli_name=cli_name, exit_code=exit_code))
+
+    return Success(msg.AIAssistant.ASSISTANT_EXITED_WITH_CODE.format(cli_name=cli_name, exit_code=exit_code), metadata={"ai_exit_code": exit_code})

titan_cli/engine/steps/command_step.py

@@ -0,0 +1,93 @@
+import os
+from subprocess import Popen, PIPE
+import re
+import shlex
+from titan_cli.core.workflows.models import WorkflowStepModel
+from titan_cli.engine.context import WorkflowContext
+from titan_cli.engine.results import Success, Error, WorkflowResult
+from titan_cli.engine.utils import get_poetry_venv_env
+
+
+def resolve_parameters_in_string(text: str, ctx: WorkflowContext) -> str:
+    """
+    Substitutes ${placeholder} in a string using values from ctx.data.
+    Public function so it can be used by workflow_executor.
+    """
+    def replace_placeholder(match):
+        placeholder = match.group(1)
+        if placeholder in ctx.data:
+            return str(ctx.data[placeholder])
+        return match.group(0)
+
+    return re.sub(r'\$\{(\w+)\}', replace_placeholder, text)
+
+
+def execute_command_step(step: WorkflowStepModel, ctx: WorkflowContext) -> WorkflowResult:
+    """
+    Executes a shell command defined in a workflow step.
+    """
+    command_template = step.command
+    if not command_template:
+        return Error("Command step is missing the 'command' attribute.")
+
+    command = resolve_parameters_in_string(command_template, ctx)
+
+    if ctx.ui:
+        ctx.ui.text.info(f"Executing command: {command}")
+
+    try:
+        use_venv = step.params.get("use_venv", False)
+        process_env = os.environ.copy()
+        cwd = ctx.get("cwd") or os.getcwd()
+
+        if use_venv:
+            if ctx.ui:
+                ctx.ui.text.body("Activating poetry virtual environment for step...", style="dim")
+            
+            venv_env = get_poetry_venv_env(cwd=cwd)
+            if venv_env:
+                process_env = venv_env
+            else:
+                return Error("Could not determine poetry virtual environment.")
+
+        # Determine command execution arguments based on security model
+        if step.use_shell:
+            # Insecure method for commands that need shell features (e.g., pipes)
+            popen_args = {"args": command, "shell": True}
+        else:
+            # Secure method: split command into a list to avoid injection
+            popen_args = {"args": shlex.split(command), "shell": False}
+
+        process = Popen(
+            **popen_args,
+            stdout=PIPE,
+            stderr=PIPE,
+            text=True,
+            cwd=cwd,
+            env=process_env
+        )
+        
+        stdout_output, stderr_output = process.communicate()
+
+        if stdout_output:
+            # Print any output from the command
+            ctx.ui.text.body(stdout_output)
+        
+        if process.returncode != 0:
+            error_message = f"Command failed with exit code {process.returncode}"
+            if stderr_output:
+                error_message += f"\n{stderr_output}"
+
+            return Error(error_message)
+
+        return Success(
+            message=f"Command '{command}' executed successfully.",
+            metadata={"command_output": stdout_output}
+        )
+
+    except FileNotFoundError:
+        command_to_report = command.split()[0] if not step.use_shell else command
+        return Error(f"Command not found: {command_to_report}")
+    except Exception as e:
+        return Error(f"An unexpected error occurred: {e}", exception=e)
+

titan_cli/engine/utils/__init__.py

@@ -0,0 +1,3 @@
+from .venv import get_poetry_venv_env
+
+__all__ = ["get_poetry_venv_env"]

titan_cli/engine/utils/venv.py

@@ -0,0 +1,31 @@
+import os
+from pathlib import Path
+from subprocess import Popen, PIPE
+from typing import Optional, Dict
+
+def get_poetry_venv_env(cwd: Optional[str] = None) -> Optional[Dict[str, str]]:
+    """
+    Detects the poetry virtual environment and returns a modified environment
+    dictionary with the venv's bin path prepended to PATH.
+
+    Args:
+        cwd: The working directory to run poetry commands from.
+
+    Returns:
+        A dictionary for the 'env' parameter of subprocess calls, or None if
+        the venv could not be determined.
+    """
+    process_env = os.environ.copy()
+    try:
+        env_proc = Popen(["poetry", "env", "info", "-p"], stdout=PIPE, stderr=PIPE, text=True, cwd=cwd)
+        venv_path, _ = env_proc.communicate()
+
+        if env_proc.returncode == 0 and venv_path.strip():
+            bin_path = Path(venv_path.strip()) / "bin"
+            process_env["PATH"] = f"{bin_path}:{process_env['PATH']}"
+            return process_env
+    except FileNotFoundError:
+        # poetry command not found
+        return None
+    
+    return None