titan-cli 0.1.0__py3-none-any.whl

titan_cli/ui/tui/screens/base.py

@@ -0,0 +1,110 @@
+"""
+Base Screen
+
+Base class for all Titan TUI screens with consistent layout.
+"""
+from textual.app import ComposeResult
+from textual.screen import Screen
+
+from titan_cli.core.config import TitanConfig
+from titan_cli.ui.tui.widgets.status_bar import StatusBarWidget
+from titan_cli.ui.tui.widgets.header import HeaderWidget
+
+
+class BaseScreen(Screen):
+    """
+    Base screen with consistent layout for all Titan screens.
+
+    Provides:
+    - Header (top)
+    - Content area (middle) - to be defined by subclasses
+    - StatusBar (bottom, above footer)
+    - Footer (bottom)
+
+    Subclasses should override `compose_content()` to define their content.
+    """
+
+    CSS = """
+    BaseScreen {
+        background: $surface;
+    }
+
+    #screen-content {
+        height: 1fr;
+        overflow-y: auto;
+    }
+    """
+
+    def __init__(self, config: TitanConfig, title: str = "Titan CLI", show_back: bool = False, show_status_bar: bool = True, **kwargs):
+        """
+        Initialize base screen.
+
+        Args:
+            config: TitanConfig instance
+            title: Title to display in header
+            show_back: Whether to show back button in header
+            show_status_bar: Whether to show status bar at bottom
+        """
+        super().__init__(**kwargs)
+        self.config = config
+        self.screen_title = title
+        self.show_back = show_back
+        self.show_status_bar = show_status_bar
+
+    def compose(self) -> ComposeResult:
+        """Compose the base screen layout."""
+        # Header with title and optional back button
+        yield HeaderWidget(title=self.screen_title, show_back=self.show_back)
+
+        # Content area - subclasses define this
+        yield from self.compose_content()
+
+        # StatusBar with current config values (optional)
+        if self.show_status_bar:
+            status_bar = StatusBarWidget(id="status-bar")
+            self._update_status_bar(status_bar)
+            yield status_bar
+
+    def _update_status_bar(self, status_bar: StatusBarWidget) -> None:
+        """
+        Update status bar with current config values.
+
+        Args:
+            status_bar: StatusBarWidget to update
+        """
+        # Get git status
+        git_branch = "N/A"
+        try:
+            git_plugin = self.config.registry.get_plugin("git")
+            if git_plugin and git_plugin.is_available():
+                git_client = git_plugin.get_client()
+                git_status = git_client.get_status()
+                git_branch = git_status.branch if git_status else "N/A"
+        except Exception:
+            pass
+
+        # Get AI info directly from config
+        ai_info = "N/A"
+        if self.config.config and self.config.config.ai and self.config.config.ai.default:
+            default_provider_id = self.config.config.ai.default
+            if default_provider_id in self.config.config.ai.providers:
+                provider_cfg = self.config.config.ai.providers[default_provider_id]
+                provider_name = provider_cfg.provider
+                model = provider_cfg.model or "default"
+                ai_info = f"{provider_name}/{model}"
+
+        # Get project name directly from config
+        project_name = self.config.get_project_name() or "N/A"
+
+        # Update status bar
+        status_bar.git_branch = git_branch
+        status_bar.ai_info = ai_info
+        status_bar.project_name = project_name
+
+    def on_header_widget_back_pressed(self, message: HeaderWidget.BackPressed) -> None:
+        """Handle back button press from header."""
+        self.action_go_back()
+
+    def action_go_back(self) -> None:
+        """Go back to previous screen. Override in subclasses if needed."""
+        self.app.pop_screen()

titan_cli/ui/tui/screens/cli_launcher.py

@@ -0,0 +1,151 @@
+"""
+CLI Launcher Screen
+
+Screen for launching external CLI tools (Claude, Gemini, etc.)
+"""
+
+from textual.app import ComposeResult
+from textual.widgets import Static, OptionList
+from textual.widgets.option_list import Option
+from textual.containers import Container
+from textual.binding import Binding
+
+from titan_cli.external_cli.launcher import CLILauncher
+from titan_cli.external_cli.configs import CLI_REGISTRY
+from .base import BaseScreen
+
+
+class CLILauncherScreen(BaseScreen):
+    """
+    Screen for selecting and launching external CLI tools.
+    """
+
+    BINDINGS = [
+        Binding("escape", "back", "Back"),
+    ]
+
+    CSS = """
+    CLILauncherScreen {
+        align: center middle;
+    }
+
+    #launcher-container {
+        width: 70%;
+        height: auto;
+        background: $surface-lighten-1;
+        border: solid $primary;
+        margin: 1;
+        padding: 2;
+    }
+
+    #launcher-title {
+        text-align: center;
+        color: $primary;
+        text-style: bold;
+        margin-bottom: 2;
+    }
+
+    .info-text {
+        color: $text-muted;
+        text-align: center;
+        margin-bottom: 2;
+    }
+
+    #cli-options {
+        height: auto;
+        border: none;
+        background: $surface-lighten-1;
+    }
+
+    #cli-options > .option-list--option {
+        padding: 1;
+    }
+
+    #cli-options > .option-list--option-highlighted {
+        padding: 1;
+    }
+    """
+
+    def __init__(self, config):
+        super().__init__(config, show_back=True)
+        self.available_clis = self._get_available_clis()
+
+    def _get_available_clis(self) -> dict:
+        """Get list of available CLI tools."""
+        available = {}
+        for cli_name, config in CLI_REGISTRY.items():
+            launcher = CLILauncher(
+                cli_name,
+                install_instructions=config.get("install_instructions"),
+                prompt_flag=config.get("prompt_flag")
+            )
+            if launcher.is_available():
+                available[cli_name] = {
+                    "launcher": launcher,
+                    "display_name": config.get("display_name", cli_name)
+                }
+        return available
+
+    def compose_content(self) -> ComposeResult:
+        """Compose the CLI launcher screen."""
+        with Container(id="launcher-container"):
+            yield Static("🚀 Launch External CLI", id="launcher-title")
+
+            if not self.available_clis:
+                yield Static(
+                    "⚠️  No external CLI tools found.\n\n"
+                    "Install Claude CLI or Gemini CLI to use this feature.\n\n"
+                    "Press ESC to go back.",
+                    classes="info-text"
+                )
+            else:
+                yield Static(
+                    "Select a CLI tool to launch:",
+                    classes="info-text"
+                )
+
+                options = [
+                    Option(info["display_name"], id=cli_name)
+                    for cli_name, info in self.available_clis.items()
+                ]
+                yield OptionList(*options, id="cli-options")
+
+    def on_mount(self) -> None:
+        """Focus the CLI list when mounted."""
+        if self.available_clis:
+            self.query_one("#cli-options").focus()
+
+    def on_option_list_option_selected(self, event: OptionList.OptionSelected) -> None:
+        """Handle CLI selection and launch immediately."""
+        cli_name = event.option.id
+
+        if cli_name not in self.available_clis:
+            self.app.notify("Invalid CLI selection", severity="error")
+            return
+
+        # Get launcher
+        launcher = self.available_clis[cli_name]["launcher"]
+        display_name = self.available_clis[cli_name]["display_name"]
+
+        # Notify user
+        self.app.notify(f"Launching {display_name}...")
+
+        # Suspend TUI and launch CLI
+        with self.app.suspend():
+            exit_code = launcher.launch(prompt=None, cwd=".")
+
+        # Show result
+        if exit_code == 0:
+            self.app.notify(f"{display_name} exited successfully", severity="information")
+        else:
+            self.app.notify(
+                f"{display_name} exited with code {exit_code}",
+                severity="warning"
+            )
+
+        # Go back to main menu
+        self.action_back()
+
+    def action_back(self) -> None:
+        """Go back to main menu."""
+        self.app.pop_screen()

titan_cli/ui/tui/screens/global_setup_wizard.py

@@ -0,0 +1,363 @@
+"""
+Global Setup Wizard Screen
+
+First-time installation wizard for configuring Titan globally.
+"""
+
+from textual.app import ComposeResult
+from textual.widgets import Static
+from textual.containers import Container, Horizontal, VerticalScroll
+from textual.binding import Binding
+
+from titan_cli.ui.tui.icons import Icons
+from titan_cli.ui.tui.widgets import Text, DimText, Button, BoldText
+from .base import BaseScreen
+
+
+class StepIndicator(Static):
+    """Widget showing a single step with status indicator."""
+
+    def __init__(self, step_number: int, title: str, status: str = "pending"):
+        self.step_number = step_number
+        self.title = title
+        self.status = status
+        super().__init__()
+
+    def render(self) -> str:
+        """Render the step with appropriate icon."""
+        if self.status == "completed":
+            icon = Icons.SUCCESS
+            style = "dim"
+        elif self.status == "in_progress":
+            icon = Icons.RUNNING
+            style = "bold cyan"
+        else:  # pending
+            icon = Icons.PENDING
+            style = "dim"
+
+        return f"[{style}]{icon} {self.step_number}. {self.title}[/{style}]"
+
+
+class GlobalSetupWizardScreen(BaseScreen):
+    """
+    First-time setup wizard for Titan.
+
+    This wizard runs when Titan is launched for the first time
+    and ~/.titan/config.toml doesn't exist.
+    """
+
+    BINDINGS = [
+        Binding("escape", "cancel", "Cancel"),
+    ]
+
+    CSS = """
+    GlobalSetupWizardScreen {
+        align: center middle;
+    }
+
+    #wizard-container {
+        width: 100%;
+        height: 1fr;
+        background: $surface-lighten-1;
+        padding: 0 2 1 2;
+    }
+
+    #steps-panel {
+        width: 20%;
+        height: 100%;
+        border: round $primary;
+        border-title-align: center;
+        background: $surface-lighten-1;
+        padding: 0;
+    }
+
+    #steps-content {
+        padding: 1;
+    }
+
+    StepIndicator {
+        height: auto;
+        margin-bottom: 1;
+    }
+
+    #content-panel {
+        width: 80%;
+        height: 100%;
+        border: round $primary;
+        border-title-align: center;
+        background: $surface-lighten-1;
+        padding: 0;
+        layout: vertical;
+    }
+
+    #content-scroll {
+        height: 1fr;
+    }
+
+    #content-area {
+        padding: 1;
+        height: auto;
+    }
+
+    #content-title {
+        color: $accent;
+        text-style: bold;
+        margin-bottom: 2;
+        height: auto;
+    }
+
+    #content-body {
+        height: auto;
+        margin-bottom: 2;
+    }
+
+    #button-container {
+        height: auto;
+        padding: 1 2;
+        background: $surface-lighten-1;
+        border-top: solid $primary;
+        align: right middle;
+    }
+    """
+
+    def __init__(self, config):
+        super().__init__(
+            config,
+            title=f"{Icons.SETTINGS} Titan Setup Wizard",
+            show_back=False,
+            show_status_bar=False
+        )
+        self.current_step = 0
+        self.wizard_data = {}
+        self._mounted = False
+
+        # Define all wizard steps
+        self.steps = [
+            {"id": "welcome", "title": "Welcome"},
+            {"id": "complete", "title": "Setup Complete"},
+        ]
+
+    def compose_content(self) -> ComposeResult:
+        """Compose the wizard screen with two panels."""
+        with Container(id="wizard-container"):
+            with Horizontal():
+                # Left panel: Steps
+                left_panel = VerticalScroll(id="steps-panel")
+                left_panel.border_title = "Setup Steps"
+                with left_panel:
+                    with Container(id="steps-content"):
+                        for i, step in enumerate(self.steps, 1):
+                            status = "in_progress" if i == 1 else "pending"
+                            yield StepIndicator(i, step["title"], status=status)
+
+                # Right panel: Content
+                right_panel = Container(id="content-panel")
+                right_panel.border_title = "Setup Configuration"
+                with right_panel:
+                    with VerticalScroll(id="content-scroll"):
+                        with Container(id="content-area"):
+                            yield Static("", id="content-title")
+                            yield Container(id="content-body")
+
+                    # Bottom buttons
+                    with Horizontal(id="button-container"):
+                        yield Button("Back", variant="default", id="back-button", disabled=True)
+                        yield Button("Next", variant="primary", id="next-button")
+                        yield Button("Cancel", variant="default", id="cancel-button")
+
+    def on_mount(self) -> None:
+        """Load the first step when mounted."""
+        if not self._mounted:
+            self._mounted = True
+            self.load_step(0)
+
+    def load_step(self, step_index: int) -> None:
+        """Load content for the given step."""
+        self.current_step = step_index
+        step = self.steps[step_index]
+
+        # Update step indicators
+        for i, indicator in enumerate(self.query(StepIndicator)):
+            if i < step_index:
+                indicator.status = "completed"
+            elif i == step_index:
+                indicator.status = "in_progress"
+            else:
+                indicator.status = "pending"
+            indicator.refresh()
+
+        # Update buttons
+        back_button = self.query_one("#back-button", Button)
+        back_button.disabled = (step_index == 0)
+
+        # Change Next button label based on step
+        next_button = self.query_one("#next-button", Button)
+        if step_index == len(self.steps) - 1:
+            next_button.label = "Finish"
+        else:
+            next_button.label = "Next"
+
+        # Load step content
+        content_title = self.query_one("#content-title", Static)
+        content_body = self.query_one("#content-body", Container)
+
+        if step["id"] == "welcome":
+            self.load_welcome_step(content_title, content_body)
+        elif step["id"] == "complete":
+            self.load_complete_step(content_title, content_body)
+
+    def load_welcome_step(self, title_widget: Static, body_widget: Container) -> None:
+        """Load Welcome step."""
+        title_widget.update("Welcome to Titan CLI!")
+
+        # Clear previous content
+        body_widget.remove_children()
+
+        # Add welcome message
+        welcome_text = Text(
+            "Thank you for installing Titan CLI!\n\n"
+            "Titan is a powerful development tools orchestrator that helps you manage Git, GitHub, "
+            "Jira, and other services with AI-powered workflows.\n\n"
+            "This wizard will help you configure Titan for first-time use."
+        )
+        body_widget.mount(welcome_text)
+
+        # Add features info
+        features = DimText(
+            "\n\nKey Features:\n"
+            "  • AI-powered commit messages and PR descriptions\n"
+            "  • Automated workflows for common tasks\n"
+            "  • Seamless integration with Git, GitHub, and Jira\n"
+            "  • Extensible plugin system\n"
+            "  • Modern terminal UI"
+        )
+        body_widget.mount(features)
+
+        # Add next steps
+        next_steps = Text(
+            "\n\nNext, you'll configure your AI provider (Claude or Gemini).\n"
+            "This is required to use Titan's AI-powered features."
+        )
+        body_widget.mount(next_steps)
+
+    def load_complete_step(self, title_widget: Static, body_widget: Container) -> None:
+        """Load Setup Complete step."""
+        title_widget.update("Setup Complete!")
+        body_widget.remove_children()
+
+        # Add completion message
+        completion_text = BoldText(
+            "Congratulations! Titan has been configured successfully.\n"
+        )
+        body_widget.mount(completion_text)
+
+        # Add next steps
+        next_steps = Text(
+            "\n\nWhat's Next?\n\n"
+            "When you run Titan from a project directory, you'll be prompted to configure "
+            "that specific project.\n\n"
+            "For now, Titan is ready to use!"
+        )
+        body_widget.mount(next_steps)
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        """Handle button presses."""
+        if event.button.id == "next-button":
+            self.handle_next()
+        elif event.button.id == "back-button":
+            self.handle_back()
+        elif event.button.id == "cancel-button":
+            self.action_cancel()
+
+    def handle_next(self) -> None:
+        """Move to next step or complete setup."""
+        # Validate and save current step data
+        if not self.validate_and_save_step():
+            return
+
+        # If on last step, complete setup
+        if self.current_step == len(self.steps) - 1:
+            self.complete_setup()
+            return
+
+        # If on welcome step, launch AI wizard before going to complete
+        if self.steps[self.current_step]["id"] == "welcome":
+            # Launch AI configuration wizard
+            from .ai_config_wizard import AIConfigWizardScreen
+
+            def on_ai_wizard_complete(result=None):
+                """Callback when AI wizard is dismissed."""
+                import logging
+                logger = logging.getLogger('titan_cli.ui.tui.screens.project_setup_wizard')
+                logger.debug(f"AI wizard complete with result={result}")
+
+                # Only proceed if AI was configured successfully
+                if result is True:
+                    logger.debug(f"AI configured successfully, moving to step {self.current_step + 1}")
+                    self.load_step(self.current_step + 1)
+                else:
+                    logger.debug("AI wizard cancelled, staying on current step")
+                    self.app.notify(
+                        "AI configuration is required to use Titan. Please configure an AI provider.",
+                        severity="warning"
+                    )
+
+            self.app.push_screen(AIConfigWizardScreen(self.config), on_ai_wizard_complete)
+            return
+
+        # Move to next step
+        if self.current_step < len(self.steps) - 1:
+            self.load_step(self.current_step + 1)
+
+    def validate_and_save_step(self) -> bool:
+        """Validate and save data from current step."""
+        step = self.steps[self.current_step]
+
+        if step["id"] == "welcome":
+            # No validation needed for welcome step
+            return True
+
+        # No other validation needed
+        return True
+
+    def handle_back(self) -> None:
+        """Move to previous step."""
+        if self.current_step > 0:
+            self.load_step(self.current_step - 1)
+
+    def complete_setup(self) -> None:
+        """Complete the global setup."""
+        import tomli
+        import tomli_w
+        from titan_cli.core.config import TitanConfig
+
+        try:
+            # Create ~/.titan directory
+            global_config_path = TitanConfig.GLOBAL_CONFIG
+            global_config_path.parent.mkdir(parents=True, exist_ok=True)
+
+            # Load existing global config (AI wizard may have already written to it)
+            global_config_data = {}
+            if global_config_path.exists():
+                with open(global_config_path, "rb") as f:
+                    global_config_data = tomli.load(f)
+
+            # Ensure version is set
+            if "version" not in global_config_data:
+                global_config_data["version"] = "1.0"
+
+            # Save global config (preserving any AI configuration)
+            with open(global_config_path, "wb") as f:
+                tomli_w.dump(global_config_data, f)
+
+            self.app.notify("Global setup completed successfully!", severity="information")
+
+            # Close wizard - the callback will handle navigation
+            self.dismiss()
+
+        except Exception as e:
+            self.app.notify(f"Failed to complete setup: {e}", severity="error")
+
+    def action_cancel(self) -> None:
+        """Cancel the setup wizard."""
+        self.app.exit(message="Setup cancelled. Titan requires initial configuration to run.")