titan-cli 0.1.0__py3-none-any.whl

titan_cli/engine/workflow_executor.py

@@ -0,0 +1,187 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+from titan_cli.core.workflows import ParsedWorkflow
+from titan_cli.core.workflows.workflow_exceptions import WorkflowExecutionError
+from titan_cli.engine.context import WorkflowContext
+from titan_cli.engine.results import WorkflowResult, Success, Error, is_error, is_skip
+from titan_cli.core.workflows.workflow_registry import WorkflowRegistry
+from titan_cli.core.plugins.plugin_registry import PluginRegistry
+from titan_cli.core.workflows.models import WorkflowStepModel
+from titan_cli.engine.steps.command_step import execute_command_step as execute_external_command_step
+from titan_cli.engine.steps.ai_assistant_step import execute_ai_assistant_step
+
+
+
+class WorkflowExecutor:
+    """
+    Executes a ParsedWorkflow by iterating through its steps,
+    resolving plugins, and performing parameter substitution.
+    """
+
+    # Core steps available to all workflows
+    CORE_STEPS = {
+        "ai_code_assistant": execute_ai_assistant_step,
+    }
+
+    def __init__(self, plugin_registry: PluginRegistry, workflow_registry: WorkflowRegistry):
+        self._plugin_registry = plugin_registry
+        self._workflow_registry = workflow_registry
+
+    def execute(self, workflow: ParsedWorkflow, ctx: WorkflowContext, params_override: Optional[Dict[str, Any]] = None) -> WorkflowResult:
+        """
+        Executes the given ParsedWorkflow.
+        """
+        # Merge workflow params into ctx.data with optional overrides
+        effective_params = {**workflow.params}
+        if params_override:
+            effective_params.update(params_override)
+
+        # Load params into ctx.data so steps can access them
+        ctx.data.update(effective_params)
+
+        # Inject workflow metadata into context
+        ctx.workflow_name = workflow.name
+        ctx.total_steps = len([s for s in workflow.steps if not s.get("hook")])
+
+        ctx.enter_workflow(workflow.name)
+        try:
+            step_index = 0
+            for step_data in workflow.steps:
+                step_config = WorkflowStepModel(**step_data)
+
+                # Hooks are resolved by the registry, so we just skip the placeholder.
+                # Check the parsed model instead of raw dict to handle auto-generated IDs
+                if step_config.hook:
+                    continue
+
+                step_index += 1
+                ctx.current_step = step_index
+
+                step_id = step_config.id
+                step_name = step_config.name or step_id
+
+                try:
+                    if step_config.workflow:
+                        step_result = self._execute_workflow_step(step_config, ctx)
+                    elif step_config.plugin and step_config.step:
+                        step_result = self._execute_plugin_step(step_config, ctx)
+                    elif step_config.command:
+                        step_result = self._execute_command_step(step_config, ctx)
+                    else:
+                        # This should be caught by model validation, but as a safeguard:
+                        step_result = Error(f"Invalid step configuration for '{step_id}'.")
+                except Exception as e:
+                    step_result = Error(f"An unexpected error occurred in step '{step_name}': {e}", e)
+
+                # Handle step result
+                if is_error(step_result):
+                    if step_config.on_error == "fail":
+                        return Error(f"Workflow failed at step '{step_name}'", step_result.exception)
+                    # else: on_error == "continue" - continue to next step
+                elif is_skip(step_result):
+                    if step_result.metadata:
+                        ctx.data.update(step_result.metadata)
+                else: # Success
+                    if step_result.metadata:
+                        ctx.data.update(step_result.metadata)
+
+        finally:
+            ctx.exit_workflow(workflow.name)
+
+        return Success(f"Workflow '{workflow.name}' finished.", {})
+
+    def _execute_workflow_step(self, step_config: WorkflowStepModel, ctx: WorkflowContext) -> WorkflowResult:
+        """Executes a nested workflow as a step."""
+        workflow_name = step_config.workflow
+        if not workflow_name:
+            return Error("Workflow step is missing the 'workflow' name.")
+
+        try:
+            sub_workflow = self._workflow_registry.get_workflow(workflow_name)
+            if not sub_workflow:
+                return Error(f"Nested workflow '{workflow_name}' not found.")
+        except Exception as e:
+            return Error(f"Failed to load workflow '{workflow_name}': {e}", e)
+
+        # We recursively call the main execute method.
+        # Pass a copy of the context data to isolate it if needed, but for now, we share it.
+        # The `enter_workflow` check will prevent infinite recursion.
+        return self.execute(sub_workflow, ctx, params_override=step_config.params)
+
+
+    def _execute_plugin_step(self, step_config: WorkflowStepModel, ctx: WorkflowContext) -> WorkflowResult:
+        plugin_name = step_config.plugin
+        step_func_name = step_config.step
+        step_params = step_config.params
+
+        # Validate required context variables
+        # This was part of `command` originally, but it's good practice for plugin steps too.
+        required_vars = step_config.params.get("requires", []) # Assuming 'requires' can be in params
+        for var in required_vars:
+            if var not in ctx.data:
+                return Error(f"Step '{step_func_name}' is missing required context variable: '{var}'")
+
+        step_func = None
+        if plugin_name == "project":
+            # Handle virtual 'project' plugin for project-specific steps
+            step_func = self._workflow_registry.get_project_step(step_func_name)
+            if not step_func:
+                return Error(f"Project step '{step_func_name}' not found in '.titan/steps/'.", WorkflowExecutionError(f"Project step '{step_func_name}' not found"))
+        elif plugin_name == "core":
+            # Handle virtual 'core' plugin for built-in core steps
+            step_func = self.CORE_STEPS.get(step_func_name)
+            if not step_func:
+                available = ", ".join(self.CORE_STEPS.keys())
+                return Error(f"Core step '{step_func_name}' not found. Available: {available}", WorkflowExecutionError(f"Core step '{step_func_name}' not found"))
+        else:
+            # Handle regular plugins
+            plugin_instance = self._plugin_registry.get_plugin(plugin_name)
+            if not plugin_instance:
+                return Error(f"Plugin '{plugin_name}' not found or not initialized.", WorkflowExecutionError(f"Plugin '{plugin_name}' not found"))
+
+            step_functions = plugin_instance.get_steps()
+            step_func = step_functions.get(step_func_name)
+            if not step_func:
+                return Error(f"Step '{step_func_name}' not found in plugin '{plugin_name}'.", WorkflowExecutionError(f"Step '{step_func_name}' not found"))
+
+        # Prepare parameters for the step function
+        resolved_params = self._resolve_parameters(step_params, ctx)
+
+        # Add resolved parameters to context data so step can access them via ctx.get()
+        ctx.data.update(resolved_params)
+
+        # Execute the step function
+        try:
+            if plugin_name == "core":
+                # Core steps receive (step: WorkflowStepModel, ctx: WorkflowContext)
+                return step_func(step_config, ctx)
+            else:
+                # Plugin and project steps receive only ctx (params are in ctx.data)
+                return step_func(ctx)
+        except Exception as e:
+            error_source = f"plugin '{plugin_name}'" if plugin_name not in ("project", "core") else f"{plugin_name} step"
+            return Error(f"Error executing step '{step_func_name}' from {error_source}: {e}", e)
+
+
+    def _execute_command_step(self, step_config: WorkflowStepModel, ctx: WorkflowContext) -> WorkflowResult: # Changed type hint to WorkflowStepModel
+        """
+        Executes a shell command using the dedicated external function.
+        """
+        # Call the external function that handles command execution
+        return execute_external_command_step(step_config, ctx)
+
+    def _resolve_parameters(self, params: Dict[str, Any], ctx: WorkflowContext) -> Dict[str, Any]:
+        """
+        Resolves parameter values by substituting placeholders from context data.
+        All workflow params are already in ctx.data.
+        """
+        from titan_cli.engine.steps.command_step import resolve_parameters_in_string
+
+        resolved = {}
+        for key, value in params.items():
+            if isinstance(value, str):
+                resolved[key] = resolve_parameters_in_string(value, ctx)
+            else:
+                resolved[key] = value # Keep non-string parameters as is
+        return resolved

titan_cli/external_cli/configs.py

@@ -0,0 +1,17 @@
+# titan_cli/utils/cli_configs.py
+"""
+Centralized registry for external CLI tool configurations.
+"""
+
+CLI_REGISTRY = {
+    "claude": {
+        "display_name": "Claude CLI",
+        "install_instructions": "Install: npm install -g @anthropic/claude-code",
+        "prompt_flag": None
+    },
+    "gemini": {
+        "display_name": "Gemini CLI",
+        "install_instructions": None,
+        "prompt_flag": "-i"
+    }
+}

titan_cli/external_cli/launcher.py

@@ -0,0 +1,65 @@
+# titan_cli/utils/cli_launcher.py
+import subprocess
+import sys
+import shutil
+from typing import Optional
+
+class CLILauncher:
+    """
+    Generic launcher for external CLI tools.
+
+    This class provides a standardized way to check for the availability of a CLI tool
+    and launch it, optionally passing an initial prompt. It abstracts away the
+    specific command-line arguments needed for interactive prompts for different tools.
+
+    To integrate a new CLI tool:
+    1. Ensure the tool is discoverable in the system's PATH.
+    2. Add its configuration to `titan_cli/utils/cli_configs.py` within the `CLI_REGISTRY`.
+       This configuration should include its `display_name`, `install_instructions` (optional),
+       and `prompt_flag` (e.g., "-i" for Gemini, or None if it takes a positional argument).
+
+    Attributes:
+        cli_name (str): The actual command to execute (e.g., "claude", "gemini").
+        install_instructions (Optional[str]): A message guiding the user on how to install the CLI.
+        prompt_flag (Optional[str]): The command-line flag used by the CLI to accept an
+                                       initial prompt while remaining interactive (e.g., "-i").
+                                       If the CLI accepts a positional argument for the prompt, set to None.
+    """
+
+    def __init__(self, cli_name: str, install_instructions: Optional[str] = None, prompt_flag: Optional[str] = None):
+        self.cli_name = cli_name
+        self.install_instructions = install_instructions
+        self.prompt_flag = prompt_flag
+
+    def is_available(self) -> bool:
+        """Check if the CLI tool is installed."""
+        return shutil.which(self.cli_name) is not None
+
+    def launch(self, prompt: Optional[str] = None, cwd: Optional[str] = None) -> int:
+        """
+        Launch the CLI tool in the current terminal.
+
+        Args:
+            prompt: Optional initial prompt to send to the CLI
+            cwd: Working directory (default: current)
+
+        Returns:
+            Exit code from the CLI tool
+        """
+        cmd = [self.cli_name]
+
+        if prompt:
+            if self.prompt_flag:
+                cmd.extend([self.prompt_flag, prompt])
+            else:
+                cmd.append(prompt)
+
+        result = subprocess.run(
+            cmd,
+            stdin=sys.stdin,
+            stdout=sys.stdout,
+            stderr=sys.stderr,
+            cwd=cwd
+        )
+
+        return result.returncode

titan_cli/messages.py

@@ -0,0 +1,121 @@
+"""
+Centralized Messages for Titan CLI
+
+All user-visible text should be defined here for:
+- Consistency across the application
+- Easy maintenance and updates
+- Future i18n support if needed
+- Clear organization by feature
+
+Usage:
+    from titan_cli.messages import msg
+
+    typer.echo(msg.CLI.VERSION.format(version="0.1.0"))
+"""
+
+
+class Messages:
+    """All user-visible messages organized by category"""
+
+    # ═══════════════════════════════════════════════════════════════
+    # CLI Core Messages
+    # ═══════════════════════════════════════════════════════════════
+
+    class CLI:
+        """Main CLI application messages"""
+        APP_NAME = "titan"
+        APP_DESCRIPTION = "Titan CLI - Development tools orchestrator"
+        VERSION = "Titan CLI v{version}"
+
+    # ═══════════════════════════════════════════════════════════════
+    # Workflow Engine
+    # ═══════════════════════════════════════════════════════════════
+
+    class Workflow:
+        """Workflow execution messages"""
+
+        # Workflow lifecycle
+        TITLE = "{emoji} {name}"
+        STEP_INFO = "[{current_step}/{total_steps}] {step_name}"
+        STEP_EXCEPTION = "Step '{step_name}' raised an exception: {error}"
+        HALTED = "Workflow halted: {message}"
+        COMPLETED_SUCCESS = "{name} completed successfully"
+        COMPLETED_WITH_SKIPS = "{name} completed with skips"
+
+        # Step result logging
+        STEP_SUCCESS = "  {symbol} {message}"
+        STEP_SKIPPED = "  {symbol} {message}"
+        STEP_ERROR = "  {symbol} {message}"
+
+        # Pre-flight checks
+        UNCOMMITTED_CHANGES_WARNING: str = "You have uncommitted changes."
+        UNCOMMITTED_CHANGES_PROMPT_TITLE: str = "Uncommitted Changes Detected"
+        WORKFLOW_STEPS_INFO: str = """This workflow will:
+  1. Prompt you for a commit message (or skip if you prefer)
+  2. Create and push the commit
+  3. Use AI to generate PR title and description automatically"""
+        CONTINUE_PROMPT: str = "Continue?"
+
+    # ═══════════════════════════════════════════════════════════════
+    # AI Assistant Step
+    # ═══════════════════════════════════════════════════════════════
+
+    class AIAssistant:
+        """Messages for the AI Code Assistant step."""
+        UI_CONTEXT_NOT_AVAILABLE = "UI context is not available for this step."
+        CONTEXT_KEY_REQUIRED = "Parameter 'context_key' is required for ai_code_assistant step"
+        NO_DATA_IN_CONTEXT = "No data found in context key '{context_key}' - skipping AI assistance"
+        INVALID_PROMPT_TEMPLATE = "Invalid prompt_template: missing placeholder {e}"
+        FAILED_TO_BUILD_PROMPT = "Failed to build prompt: {e}"
+        CONFIRM_LAUNCH_ASSISTANT = "Would you like AI assistance to help fix these issues?"
+        SELECT_ASSISTANT_CLI = "Select which AI assistant to use"
+        DECLINED_ASSISTANCE_STOPPED = "User declined AI assistance - workflow stopped"
+        DECLINED_ASSISTANCE_SKIPPED = "User declined AI assistance"
+        NO_ASSISTANT_CLI_FOUND = "No AI coding assistant CLI found"
+        LAUNCHING_ASSISTANT = "Launching {cli_name}..."
+        PROMPT_PREVIEW = "Prompt: {prompt_preview}"
+        BACK_IN_TITAN = "Back in Titan workflow"
+        ASSISTANT_EXITED_WITH_CODE = "{cli_name} exited with code {exit_code}"
+
+    # ═══════════════════════════════════════════════════════════════
+    # Generic Error Messages
+    # ═══════════════════════════════════════════════════════════════
+
+    class Errors:
+        """Generic error messages"""
+
+        # Plugin / Core Errors
+        PLUGIN_LOAD_FAILED = "Failed to load plugin '{plugin_name}': {error}"
+        PLUGIN_INIT_FAILED = "Failed to initialize plugin '{plugin_name}': {error}"
+        CONFIG_PARSE_ERROR = "Failed to parse configuration file at {file_path}: {error}"
+
+        # File system
+        FILE_NOT_FOUND = "File not found: {path}"
+        FILE_READ_ERROR = "Cannot read file: {path}"
+        FILE_WRITE_ERROR = "Cannot write file: {path}"
+        DIRECTORY_NOT_FOUND = "Directory not found: {path}"
+        PERMISSION_DENIED = "Permission denied: {path}"
+
+        # Input validation
+        INVALID_INPUT = "Invalid input: {value}"
+        MISSING_REQUIRED = "Missing required field: {field}"
+        INVALID_FORMAT = "Invalid format: {value}"
+
+        # Network
+        NETWORK_ERROR = "Network error: {error}"
+        TIMEOUT = "Operation timed out"
+        CONNECTION_FAILED = "Connection failed: {error}"
+
+        # General
+        UNKNOWN_ERROR = "An unknown error occurred: {error}"
+        NOT_IMPLEMENTED = "Feature not implemented yet"
+        OPERATION_CANCELLED = "Operation cancelled"
+        OPERATION_CANCELLED_NO_CHANGES = "Operation cancelled. No changes were made."
+
+        # Config specific
+        CONFIG_WRITE_FAILED = "Failed to write configuration file: {error}"
+        PROJECT_ROOT_NOT_SET = "Project root not set. Cannot discover projects."
+
+
+# Singleton instance for easy access
+msg = Messages()

titan_cli/ui/tui/__init__.py

@@ -0,0 +1,205 @@
+"""
+Titan TUI Module
+
+Textual-based Terminal User Interface for Titan CLI.
+"""
+from .app import TitanApp
+
+__all__ = ["TitanApp"]
+
+
+def launch_tui():
+    """
+    Launch the Titan TUI application.
+
+    This is the main entry point for running Titan in TUI mode.
+
+    Flow:
+    1. Check if global config exists (~/.titan/config.toml)
+       - If NO: Launch global setup wizard
+       - If YES: Continue
+    2. Check if project config exists (./.titan/config.toml)
+       - If NO: Launch project setup wizard
+       - If YES: Continue to main menu
+    """
+    from pathlib import Path
+    from titan_cli.core.config import TitanConfig
+    from titan_cli.core.plugins.plugin_registry import PluginRegistry
+    from .screens import GlobalSetupWizardScreen, ProjectSetupWizardScreen, MainMenuScreen
+
+    # Check if global config exists
+    global_config_path = TitanConfig.GLOBAL_CONFIG
+
+    if not global_config_path.exists():
+        # First-time setup: Launch global setup wizard
+        plugin_registry = PluginRegistry()
+        config = TitanConfig(registry=plugin_registry)
+
+        # We'll create a special wrapper screen that handles the wizard flow
+        from .screens.base import BaseScreen
+        from textual.app import ComposeResult
+        from textual.containers import Container
+
+        class WizardFlowScreen(BaseScreen):
+            """Temporary screen to manage wizard flow."""
+
+            def __init__(self, config, *args, **kwargs):
+                super().__init__(config, title="Setup", show_back=False, *args, **kwargs)
+
+            def compose_content(self) -> ComposeResult:
+                # This won't be used, we push wizard immediately
+                yield Container()
+
+            def on_mount(self) -> None:
+                """Push the global wizard on mount."""
+                def on_project_wizard_complete(_=None):
+                    """After project wizard completes, show main menu."""
+                    # Reload project config without resetting plugins
+                    from titan_cli.core.secrets import SecretManager
+                    from titan_cli.core.models import TitanConfigModel
+
+                    self.config.project_config_path = Path.cwd() / ".titan" / "config.toml"
+                    self.config.project_config = self.config._load_toml(self.config.project_config_path)
+
+                    # Merge configs and update
+                    merged = self.config._merge_configs(self.config.global_config, self.config.project_config)
+                    self.config.config = TitanConfigModel(**merged)
+
+                    # Update secrets manager to use current project
+                    self.config.secrets = SecretManager(project_path=Path.cwd())
+
+                    # Initialize only the configured plugins (without reset)
+                    self.config.registry.initialize_plugins(config=self.config, secrets=self.config.secrets)
+
+                    # Reload workflow registry to reflect enabled/disabled plugins
+                    self.config.workflows.reload()
+
+                    # Pop all screens except the base one, then push main menu
+                    # WizardFlowScreen is still there, so we need to pop it too
+                    # Stack after project wizard completes: [WizardFlowScreen]
+                    # We want: [MainMenuScreen]
+                    self.app.pop_screen()  # Remove WizardFlowScreen
+                    self.app.push_screen(MainMenuScreen(self.config))
+
+                def on_global_wizard_complete(_=None):
+                    """After global wizard completes, check for project config."""
+                    from titan_cli.core.models import TitanConfigModel
+
+                    # Reload global config
+                    self.config.global_config = self.config._load_toml(self.config._global_config_path)
+
+                    # Update config.config with the new global config
+                    # (merge with empty project config since we don't have one yet)
+                    merged = self.config._merge_configs(self.config.global_config, {})
+                    self.config.config = TitanConfigModel(**merged)
+
+                    # Check if project config exists
+                    project_config_path = Path.cwd() / ".titan" / "config.toml"
+
+                    if not project_config_path.exists():
+                        # Launch project setup wizard with callback to show main menu
+                        self.app.push_screen(
+                            ProjectSetupWizardScreen(self.config, Path.cwd()),
+                            on_project_wizard_complete
+                        )
+                    else:
+                        # Project is configured, reload configs without resetting plugins
+                        from titan_cli.core.secrets import SecretManager
+                        from titan_cli.core.models import TitanConfigModel
+
+                        self.config.project_config_path = project_config_path
+                        self.config.project_config = self.config._load_toml(self.config.project_config_path)
+
+                        # Merge configs and update
+                        merged = self.config._merge_configs(self.config.global_config, self.config.project_config)
+                        self.config.config = TitanConfigModel(**merged)
+
+                        # Update secrets manager to use current project
+                        self.config.secrets = SecretManager(project_path=Path.cwd())
+
+                        # Initialize plugins with new config
+                        self.config.registry.initialize_plugins(config=self.config, secrets=self.config.secrets)
+
+                        # Reload workflow registry to reflect enabled/disabled plugins
+                        self.config.workflows.reload()
+
+                        # Stack: [WizardFlowScreen]
+                        # We want: [MainMenuScreen]
+                        self.app.pop_screen()  # Remove WizardFlowScreen
+                        self.app.push_screen(MainMenuScreen(self.config))
+
+                # Push global wizard
+                self.app.push_screen(GlobalSetupWizardScreen(self.config), on_global_wizard_complete)
+
+        # Create app with the flow screen
+        app = TitanApp(config=config, initial_screen=WizardFlowScreen(config))
+        app.run()
+        return
+
+    # Global config exists, initialize normally
+    plugin_registry = PluginRegistry()
+    config = TitanConfig(registry=plugin_registry)
+
+    # Check if project config exists in current directory
+    project_config_path = Path.cwd() / ".titan" / "config.toml"
+
+    if not project_config_path.exists():
+        # Project not configured: Launch project setup wizard
+        # Create a wrapper screen similar to global wizard flow
+        from .screens.base import BaseScreen
+        from textual.app import ComposeResult
+        from textual.containers import Container
+
+        class ProjectWizardFlowScreen(BaseScreen):
+            """Temporary screen to manage project wizard flow."""
+
+            def __init__(self, config, *args, **kwargs):
+                super().__init__(config, title="Project Setup", show_back=False, *args, **kwargs)
+
+            def compose_content(self) -> ComposeResult:
+                # This won't be used, we push wizard immediately
+                yield Container()
+
+            def on_mount(self) -> None:
+                """Push the project wizard on mount."""
+                def on_project_wizard_complete(_=None):
+                    """After project wizard completes, show main menu."""
+                    # Reload project config without resetting plugins
+                    from pathlib import Path
+                    from titan_cli.core.secrets import SecretManager
+                    from titan_cli.core.models import TitanConfigModel
+
+                    self.config.project_config_path = Path.cwd() / ".titan" / "config.toml"
+                    self.config.project_config = self.config._load_toml(self.config.project_config_path)
+
+                    # Merge configs and update
+                    merged = self.config._merge_configs(self.config.global_config, self.config.project_config)
+                    self.config.config = TitanConfigModel(**merged)
+
+                    # Update secrets manager to use current project
+                    self.config.secrets = SecretManager(project_path=Path.cwd())
+
+                    # Initialize only the configured plugins (without reset)
+                    self.config.registry.initialize_plugins(config=self.config, secrets=self.config.secrets)
+
+                    # Reload workflow registry to reflect enabled/disabled plugins
+                    self.config.workflows.reload()
+
+                    # Pop this flow screen and show main menu
+                    self.app.pop_screen()  # Remove ProjectWizardFlowScreen
+                    self.app.push_screen(MainMenuScreen(self.config))
+
+                # Push project wizard
+                self.app.push_screen(
+                    ProjectSetupWizardScreen(self.config, Path.cwd()),
+                    on_project_wizard_complete
+                )
+
+        # Create app with the flow screen
+        app = TitanApp(config=config, initial_screen=ProjectWizardFlowScreen(config))
+        app.run()
+        return
+
+    # Both global and project configs exist: Run normally
+    app = TitanApp(config=config)
+    app.run()