titan-cli 0.1.0__py3-none-any.whl

titan_cli/ui/tui/screens/main_menu.py

@@ -0,0 +1,162 @@
+"""
+Main Menu Screen
+
+The primary navigation screen for Titan TUI.
+"""
+
+from textual.app import ComposeResult
+from textual.widgets import OptionList
+from textual.widgets.option_list import Option
+from textual.containers import Container
+
+from titan_cli.ui.tui.icons import Icons
+from .base import BaseScreen
+
+from .cli_launcher import CLILauncherScreen
+from .ai_config import AIConfigScreen
+from .plugin_management import PluginManagementScreen
+
+class MainMenuScreen(BaseScreen):
+    """
+    Main menu screen with navigation options.
+
+    Displays the primary actions available in Titan:
+    - Launch External CLI
+    - Project Management
+    - Workflows
+    - Plugin Management
+    - AI Configuration
+    - Switch Project
+    - Exit
+    """
+
+    BINDINGS = [
+        ("q", "quit", "Quit"),
+        ("escape", "quit", "Quit"),
+    ]
+
+    CSS = """
+    MainMenuScreen {
+        align: center middle;
+    }
+
+    #menu-container {
+        width: 70%;
+        height: 1fr;
+        background: $surface-lighten-1;
+        border: solid $primary;
+        margin: 1;
+        padding: 1 0;
+    }
+
+    #menu-title {
+        text-align: center;
+        color: $primary;
+        text-style: bold;
+        margin-bottom: 1;
+    }
+
+    OptionList {
+        height: auto;
+        border: none;
+        background: $surface-lighten-1;
+    }
+
+    OptionList:focus {
+        border: none;
+        background: $surface-lighten-1;
+    }
+
+    OptionList > .option-list--option {
+        padding: 1 2;
+        background: $surface-lighten-1;
+        border-left: none;
+    }
+
+    OptionList > .option-list--option-highlighted {
+        background: $primary;
+        border-left: none;
+    }
+
+    OptionList:focus > .option-list--option {
+        border-left: none;
+    }
+
+    OptionList:focus > .option-list--option-highlighted {
+        border-left: none;
+    }
+
+    """
+
+    def compose_content(self) -> ComposeResult:
+        """Compose the main menu content."""
+        with Container(id="menu-container"):
+
+            # Build menu options
+            options = [
+                Option("🚀 Launch External CLI", id="cli"),
+            ]
+
+            # Only show Workflows if there are enabled plugins
+            installed_plugins = self.config.registry.list_installed()
+            enabled_plugins = [
+                p for p in installed_plugins if self.config.is_plugin_enabled(p)
+            ]
+            if enabled_plugins:
+                options.append(Option(f"{Icons.WORKFLOW} Workflows", id="run_workflow"))
+
+            options.extend(
+                [
+                    Option(f"{Icons.PLUGIN} Plugin Management", id="plugin_management"),
+                    Option(f"{Icons.SETTINGS}  AI Configuration", id="ai_config"),
+                ]
+            )
+
+            yield OptionList(*options)
+
+    def on_option_list_option_selected(self, event: OptionList.OptionSelected) -> None:
+        """Handle menu option selection."""
+        action = event.option.id
+
+        if action == "exit":
+            self.app.exit()
+        elif action == "cli":
+            self.handle_cli_action()
+        elif action == "projects":
+            self.handle_projects_action()
+        elif action == "run_workflow":
+            self.handle_workflow_action()
+        elif action == "plugin_management":
+            self.handle_plugin_management_action()
+        elif action == "ai_config":
+            self.handle_ai_config_action()
+
+    def handle_cli_action(self) -> None:
+        """Handle Launch External CLI action."""
+        self.app.push_screen(CLILauncherScreen(self.config))
+
+    def handle_projects_action(self) -> None:
+        """Handle Project Management action."""
+        self.app.notify("Project management - Coming soon!")
+
+    def handle_workflow_action(self) -> None:
+        """Handle Workflows action."""
+        from .workflows import WorkflowsScreen
+
+        self.app.push_screen(WorkflowsScreen(self.config))
+
+    def handle_plugin_management_action(self) -> None:
+        """Handle Plugin Management action."""
+        self.app.push_screen(PluginManagementScreen(self.config))
+
+    def handle_ai_config_action(self) -> None:
+        """Handle AI Configuration action."""
+        self.app.push_screen(AIConfigScreen(self.config))
+
+    def handle_switch_project_action(self) -> None:
+        """Handle Switch Project action."""
+        self.app.notify("Switch project - Coming soon!")
+
+    def action_quit(self) -> None:
+        """Quit the application."""
+        self.app.exit()

titan_cli/ui/tui/screens/plugin_config_wizard.py

@@ -0,0 +1,550 @@
+"""
+Plugin Configuration Wizard Screen
+
+Generic wizard that adapts to any plugin's configuration schema.
+Each plugin can have different configuration steps based on its schema.
+"""
+
+import logging
+from textual.app import ComposeResult
+from textual.widgets import Static, Input
+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
+
+# Use the same logger as project_setup_wizard
+logger = logging.getLogger('titan_cli.ui.tui.screens.project_setup_wizard')
+
+
+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 PluginConfigWizardScreen(BaseScreen):
+    """
+    Generic wizard for configuring any plugin.
+
+    Adapts its steps based on the plugin's configuration schema.
+    """
+
+    BINDINGS = [
+        Binding("escape", "cancel", "Cancel"),
+    ]
+
+    CSS = """
+    PluginConfigWizardScreen {
+        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;
+    }
+
+    .field-label {
+        margin-top: 1;
+        margin-bottom: 0;
+    }
+
+    Input {
+        width: 100%;
+        margin-bottom: 2;
+        border: solid $accent;
+    }
+
+    Input:focus {
+        border: solid $primary;
+    }
+    """
+
+    def __init__(self, config, plugin_name: str):
+        super().__init__(
+            config,
+            title=f"{Icons.SETTINGS} Configure {plugin_name}",
+            show_back=False,
+            show_status_bar=False
+        )
+        self.plugin_name = plugin_name
+        self.current_step = 0
+        self.config_data = {}
+        self.steps = []
+        self.schema = None
+        self.properties = {}
+        self.required_fields = []
+
+    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 = "Configuration Steps"
+                with left_panel:
+                    with Container(id="steps-content"):
+                        # Steps will be added dynamically
+                        pass
+
+                # Right panel: Content
+                right_panel = Container(id="content-panel")
+                right_panel.border_title = "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 plugin schema and build steps."""
+        # Get plugin instance directly from registry's internal dict
+        logger.debug(f"PluginConfigWizard mounted for: '{self.plugin_name}'")
+        logger.debug(f"Registry plugins: {list(self.config.registry._plugins.keys())}")
+
+        plugin = self.config.registry._plugins.get(self.plugin_name)
+
+        if not plugin:
+            available = list(self.config.registry._plugins.keys())
+            logger.error(f"Plugin '{self.plugin_name}' not found. Available: {available}")
+            self.app.notify(f"Plugin '{self.plugin_name}' not found", severity="error")
+            self.dismiss(result=False)
+            return
+
+        # Check if plugin has configuration schema
+        if not hasattr(plugin, "get_config_schema"):
+            logger.debug(f"Plugin '{self.plugin_name}' has no config schema")
+            self.dismiss(result=True)
+            return
+
+        try:
+            self.schema = plugin.get_config_schema()
+            logger.debug(f"Got schema for '{self.plugin_name}': {self.schema}")
+        except Exception as e:
+            logger.error(f"Failed to get config schema: {e}")
+            self.app.notify(f"Failed to get config schema: {e}", severity="error")
+            self.dismiss(result=False)
+            return
+
+        self.properties = self.schema.get("properties", {})
+        self.required_fields = self.schema.get("required", [])
+
+        logger.debug(f"Properties: {list(self.properties.keys())}")
+        logger.debug(f"Required fields: {self.required_fields}")
+
+        if not self.properties:
+            logger.debug(f"Plugin '{self.plugin_name}' has no config fields")
+            self.dismiss(result=True)
+            return
+
+        # Build steps based on field types
+        self._build_steps()
+        self._render_step_indicators()
+        self.load_step(0)
+
+    def _build_steps(self):
+        """Build wizard steps based on plugin configuration schema."""
+        # Group fields by type/category
+        # For now, we'll create one step per field for simplicity
+        # In the future, plugins could define custom step grouping
+
+        for field_name in self.properties.keys():
+            self.steps.append({
+                "id": field_name,
+                "title": field_name.replace("_", " ").title(),
+                "field": field_name
+            })
+
+        # Add review step
+        self.steps.append({
+            "id": "review",
+            "title": "Review",
+            "field": None
+        })
+
+    def _render_step_indicators(self):
+        """Render step indicators in the left panel."""
+        steps_content = self.query_one("#steps-content", Container)
+
+        for i, step in enumerate(self.steps, 1):
+            status = "in_progress" if i == 1 else "pending"
+            steps_content.mount(StepIndicator(i, step["title"], status=status))
+
+    def load_step(self, step_index: int):
+        """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)
+
+        next_button = self.query_one("#next-button", Button)
+        if step_index == len(self.steps) - 1:
+            next_button.label = "Save"
+        else:
+            next_button.label = "Next"
+
+        # Load step content
+        if step["id"] == "review":
+            self.load_review_step()
+        else:
+            self.load_field_step(step["field"])
+
+    def load_field_step(self, field_name: str):
+        """Load a configuration field step."""
+        content_title = self.query_one("#content-title", Static)
+        content_body = self.query_one("#content-body", Container)
+
+        content_title.update(field_name.replace("_", " ").title())
+        content_body.remove_children()
+
+        field_schema = self.properties[field_name]
+        description = field_schema.get("description", "")
+        field_format = field_schema.get("format", "")
+        default_value = field_schema.get("default")
+        is_required = field_name in self.required_fields
+
+        # Detect if secret
+        is_secret = (
+            "token" in field_name.lower() or
+            "password" in field_name.lower() or
+            "secret" in field_name.lower() or
+            "api_key" in field_name.lower() or
+            field_format == "password"
+        )
+
+        # Show description
+        if description:
+            desc_text = Text(f"{description}\n")
+            content_body.mount(desc_text)
+
+        # Show if required
+        if is_required:
+            req_text = BoldText("This field is required.")
+            content_body.mount(req_text)
+        else:
+            opt_text = DimText("This field is optional.")
+            content_body.mount(opt_text)
+
+        # Check for existing value
+        current_value = self.config_data.get(field_name)
+        if current_value is None:
+            current_value = default_value
+
+        # For secrets, check keychain
+        if is_secret:
+            project_name = self.config.get_project_name()
+            secret_key = f"{self.plugin_name}_{field_name}"
+            keychain_key = f"{project_name}_{secret_key}" if project_name else secret_key
+            existing_secret = self.config.secrets.get(keychain_key) or self.config.secrets.get(secret_key)
+
+            if existing_secret:
+                info = DimText("\n\nAlready configured. Leave blank to keep existing value.")
+                content_body.mount(info)
+
+        # Create input
+        input_value = ""
+        if not is_secret and current_value is not None:
+            input_value = str(current_value)
+
+        input_widget = Input(
+            value=input_value,
+            placeholder=f"Enter {field_name}...",
+            password=is_secret,
+            id=f"input-{field_name}"
+        )
+        input_widget.styles.margin = (2, 0, 0, 0)
+        content_body.mount(input_widget)
+
+        # Focus input
+        self.call_after_refresh(lambda: input_widget.focus())
+
+    def load_review_step(self):
+        """Load review step showing all configuration."""
+        content_title = self.query_one("#content-title", Static)
+        content_body = self.query_one("#content-body", Container)
+
+        content_title.update("Review Configuration")
+        content_body.remove_children()
+
+        desc = Text("Please review your configuration before saving.\n")
+        content_body.mount(desc)
+
+        # Show all configured values
+        for field_name, value in self.config_data.items():
+            is_secret = (
+                "token" in field_name.lower() or
+                "password" in field_name.lower() or
+                "secret" in field_name.lower() or
+                "api_key" in field_name.lower()
+            )
+
+            label = BoldText(f"\n{field_name.replace('_', ' ').title()}:")
+            content_body.mount(label)
+
+            if is_secret:
+                value_text = DimText("  ••••••••••••")
+            else:
+                value_text = DimText(f"  {value}")
+            content_body.mount(value_text)
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        """Handle Enter key in input fields."""
+        self.handle_next()
+
+    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 save."""
+        # Validate and save current step
+        if not self.validate_and_save_step():
+            return
+
+        # If on last step, save configuration
+        if self.current_step == len(self.steps) - 1:
+            self.save_configuration()
+            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 current step data."""
+        step = self.steps[self.current_step]
+
+        if step["id"] == "review":
+            # No validation needed
+            return True
+
+        # Get field input
+        field_name = step["field"]
+        field_schema = self.properties[field_name]
+        is_required = field_name in self.required_fields
+
+        try:
+            input_widget = self.query_one(f"#input-{field_name}", Input)
+            value = input_widget.value.strip()
+
+            # Check for existing secret
+            is_secret = (
+                "token" in field_name.lower() or
+                "password" in field_name.lower() or
+                "secret" in field_name.lower() or
+                "api_key" in field_name.lower()
+            )
+
+            if is_secret:
+                project_name = self.config.get_project_name()
+                secret_key = f"{self.plugin_name}_{field_name}"
+                keychain_key = f"{project_name}_{secret_key}" if project_name else secret_key
+                existing_secret = self.config.secrets.get(keychain_key) or self.config.secrets.get(secret_key)
+
+                if not value and existing_secret:
+                    # Keep existing
+                    self.config_data[field_name] = {"_is_secret": True, "_existing": True}
+                    return True
+                elif not value and is_required:
+                    self.app.notify(f"{field_name} is required", severity="warning")
+                    return False
+                elif value:
+                    self.config_data[field_name] = {"_is_secret": True, "_value": value}
+                    return True
+                return True
+
+            # Validate required
+            if is_required and not value:
+                self.app.notify(f"{field_name} is required", severity="warning")
+                return False
+
+            # Skip empty optional fields
+            if not value:
+                return True
+
+            # Type conversion
+            field_type = field_schema.get("type")
+            if field_type == "integer":
+                try:
+                    value = int(value)
+                except ValueError:
+                    self.app.notify(f"{field_name} must be a number", severity="warning")
+                    return False
+            elif field_type == "boolean":
+                value = value.lower() in ("true", "yes", "1")
+
+            self.config_data[field_name] = value
+            return True
+
+        except Exception:
+            self.app.notify("Please enter a value", severity="error")
+            return False
+
+    def handle_back(self) -> None:
+        """Move to previous step."""
+        if self.current_step > 0:
+            self.load_step(self.current_step - 1)
+
+    def save_configuration(self) -> None:
+        """Save plugin configuration."""
+        import tomli
+        import tomli_w
+
+        try:
+            project_cfg_path = self.config.project_config_path
+            if not project_cfg_path:
+                self.app.notify("No project config found", severity="error")
+                return
+
+            project_cfg_dict = {}
+            if project_cfg_path.exists():
+                with open(project_cfg_path, "rb") as f:
+                    project_cfg_dict = tomli.load(f)
+
+            plugins_table = project_cfg_dict.setdefault("plugins", {})
+            plugin_specific_table = plugins_table.setdefault(self.plugin_name, {})
+            plugin_config_table = plugin_specific_table.setdefault("config", {})
+
+            # Separate secrets from regular config
+            secrets_to_save = {}
+            config_values = {}
+
+            for field_name, value in self.config_data.items():
+                if isinstance(value, dict) and value.get("_is_secret"):
+                    secret_key = f"{self.plugin_name}_{field_name}"
+                    if value.get("_existing"):
+                        # Keep existing secret
+                        project_name = self.config.get_project_name()
+                        keychain_key = f"{project_name}_{secret_key}" if project_name else secret_key
+                        existing = self.config.secrets.get(keychain_key) or self.config.secrets.get(secret_key)
+                        if existing:
+                            secrets_to_save[secret_key] = existing
+                    else:
+                        secrets_to_save[secret_key] = value["_value"]
+                else:
+                    config_values[field_name] = value
+
+            # Update config
+            plugin_config_table.update(config_values)
+
+            # Write config file
+            with open(project_cfg_path, "wb") as f:
+                tomli_w.dump(project_cfg_dict, f)
+
+            # Save secrets
+            project_name = self.config.get_project_name()
+            for secret_key, secret_value in secrets_to_save.items():
+                keychain_key = f"{project_name}_{secret_key}" if project_name else secret_key
+                self.config.secrets.set(keychain_key, secret_value, scope="user")
+
+            self.app.notify(f"Plugin '{self.plugin_name}' configured successfully!", severity="information")
+            self.dismiss(result=True)
+
+        except Exception as e:
+            self.app.notify(f"Failed to save configuration: {e}", severity="error")
+
+    def action_cancel(self) -> None:
+        """Cancel configuration."""
+        self.dismiss(result=False)