codemaster-cli 2.2.0__py3-none-any.whl

vibe/setup/onboarding/screens/api_key.py

@@ -0,0 +1,200 @@
+from __future__ import annotations
+
+import os
+from typing import ClassVar
+
+from dotenv import set_key
+from textual.app import ComposeResult
+from textual.binding import Binding, BindingType
+from textual.containers import Center, Horizontal, Vertical
+from textual.events import MouseUp
+from textual.validation import Length
+from textual.widgets import Input, Link, Static
+
+from vibe.cli.clipboard import copy_selection_to_clipboard
+from vibe.cli.textual_ui.widgets.no_markup_static import NoMarkupStatic
+from vibe.core.config import Backend, VibeConfig
+from vibe.core.paths.global_paths import GLOBAL_ENV_FILE
+from vibe.core.telemetry.send import TelemetryClient
+from vibe.setup.onboarding.base import OnboardingScreen
+
+PROVIDER_HELP = {
+    "mistral": ("https://console.mistral.ai/codestral/cli", "Mistral AI Studio")
+}
+CONFIG_DOCS_URL = (
+    "https://github.com/marshal0004/CodeMaster#configuration"
+)
+
+
+def _save_api_key_to_env_file(env_key: str, api_key: str) -> None:
+    GLOBAL_ENV_FILE.path.parent.mkdir(parents=True, exist_ok=True)
+    set_key(GLOBAL_ENV_FILE.path, env_key, api_key)
+
+
+class ApiKeyScreen(OnboardingScreen):
+    BINDINGS: ClassVar[list[BindingType]] = [
+        Binding("ctrl+c", "cancel", "Cancel", show=False),
+        Binding("escape", "cancel", "Cancel", show=False),
+    ]
+
+    NEXT_SCREEN = None
+
+    def __init__(self) -> None:
+        super().__init__()
+        import os
+        # Check if model was selected in provider screen
+        selected_model = os.environ.get("_CODEMASTER_SELECTED_MODEL")
+        if selected_model:
+            try:
+                config = VibeConfig.model_construct()
+                config.active_model = selected_model
+                active_model = config.get_active_model()
+                self.provider = config.get_provider_for_model(active_model)
+            except Exception:
+                config = VibeConfig.model_construct()
+                active_model = config.get_active_model()
+                self.provider = config.get_provider_for_model(active_model)
+        else:
+            config = VibeConfig.model_construct()
+            active_model = config.get_active_model()
+            self.provider = config.get_provider_for_model(active_model)
+        # Ollama and other local providers don't require an API key
+        self._skip_key = not bool(self.provider.api_key_env_var)
+
+
+
+    def _compose_provider_link(self, provider_name: str) -> ComposeResult:
+        if self.provider.name not in PROVIDER_HELP:
+            return
+
+        help_url, help_name = PROVIDER_HELP[self.provider.name]
+        yield NoMarkupStatic(f"Grab your {provider_name} API key from the {help_name}:")
+        yield Center(
+            Horizontal(
+                NoMarkupStatic("→ ", classes="link-chevron"),
+                Link(help_url, url=help_url),
+                classes="link-row",
+            )
+        )
+
+    def _compose_config_docs(self) -> ComposeResult:
+        yield Static("[dim]Learn more about codeMaster configuration:[/]")
+        yield Horizontal(
+            NoMarkupStatic("→ ", classes="link-chevron"),
+            Link(CONFIG_DOCS_URL, url=CONFIG_DOCS_URL),
+            classes="link-row",
+        )
+
+    def _compose_local_provider(self) -> ComposeResult:
+        """Compose UI for local providers (e.g. Ollama) that need no API key."""
+        provider_name = self.provider.name.capitalize()
+        with Vertical(id="api-key-outer"):
+            yield NoMarkupStatic("", classes="spacer")
+            yield Center(NoMarkupStatic("Local provider detected!", id="api-key-title"))
+            with Center():
+                with Vertical(id="api-key-content"):
+                    yield NoMarkupStatic(
+                        f"Provider '{provider_name}' requires no API key.",
+                        id="paste-hint",
+                    )
+                    yield NoMarkupStatic(
+                        "Make sure Ollama is running: ollama serve",
+                        id="ollama-hint",
+                    )
+                    yield NoMarkupStatic(
+                        "Press Enter to continue ↵", id="enter-continue"
+                    )
+            yield NoMarkupStatic("", classes="spacer")
+            yield Vertical(
+                Vertical(*self._compose_config_docs(), id="config-docs-group"),
+                id="config-docs-section",
+            )
+
+    def compose(self) -> ComposeResult:
+        if self._skip_key:
+            yield from self._compose_local_provider()
+            return
+
+        provider_name = self.provider.name.capitalize()
+
+        self.input_widget = Input(
+            password=True,
+            id="key",
+            placeholder="Paste your API key here",
+            validators=[Length(minimum=1, failure_description="No API key provided.")],
+        )
+
+        with Vertical(id="api-key-outer"):
+            yield NoMarkupStatic("", classes="spacer")
+            yield Center(NoMarkupStatic("One last thing...", id="api-key-title"))
+            with Center():
+                with Vertical(id="api-key-content"):
+                    yield from self._compose_provider_link(provider_name)
+                    yield NoMarkupStatic(
+                        "...and paste it below to finish the setup:", id="paste-hint"
+                    )
+                    yield Center(Horizontal(self.input_widget, id="input-box"))
+                    yield NoMarkupStatic("", id="feedback")
+            yield NoMarkupStatic("", classes="spacer")
+            yield Vertical(
+                Vertical(*self._compose_config_docs(), id="config-docs-group"),
+                id="config-docs-section",
+            )
+
+    def on_mount(self) -> None:
+        if self._skip_key:
+            # Local provider (Ollama etc.) — no API key required
+            self.focus()
+            return
+        self.input_widget.focus()
+
+    def on_key(self, event: object) -> None:
+        """Handle Enter key for local provider confirmation."""
+        if self._skip_key:
+            from textual.events import Key
+            if isinstance(event, Key) and event.key == "enter":
+                self.app.exit("completed")
+
+    def on_input_changed(self, event: Input.Changed) -> None:
+        feedback = self.query_one("#feedback", NoMarkupStatic)
+        input_box = self.query_one("#input-box")
+
+        if event.validation_result is None:
+            return
+
+        input_box.remove_class("valid", "invalid")
+        feedback.remove_class("error", "success")
+
+        if event.validation_result.is_valid:
+            feedback.update("Press Enter to submit ↵")
+            feedback.add_class("success")
+            input_box.add_class("valid")
+            return
+
+        descriptions = event.validation_result.failure_descriptions
+        feedback.update(descriptions[0])
+        feedback.add_class("error")
+        input_box.add_class("invalid")
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        if event.validation_result and event.validation_result.is_valid:
+            self._save_and_finish(event.value)
+
+    def _save_and_finish(self, api_key: str) -> None:
+        env_key = self.provider.api_key_env_var
+        os.environ[env_key] = api_key
+        try:
+            _save_api_key_to_env_file(env_key, api_key)
+        except OSError as err:
+            self.app.exit(f"save_error:{err}")
+            return
+        if self.provider.backend == Backend.MISTRAL:
+            try:
+                telemetry = TelemetryClient(config_getter=VibeConfig)
+                telemetry.send_onboarding_api_key_added()
+            except Exception:
+                pass  # Telemetry is fire-and-forget; don't fail onboarding
+        self.app.exit("completed")
+
+    def on_mouse_up(self, event: MouseUp) -> None:
+        copy_selection_to_clipboard(self.app)

vibe/setup/onboarding/screens/provider_selection.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+from typing import ClassVar
+
+from textual.app import ComposeResult
+from textual.binding import Binding, BindingType
+from textual.containers import Center, Vertical
+from textual.widgets import Button, Static
+
+from vibe.cli.textual_ui.widgets.no_markup_static import NoMarkupStatic
+from vibe.core.config import VibeConfig
+from vibe.setup.onboarding.base import OnboardingScreen
+
+
+class ProviderSelectionScreen(OnboardingScreen):
+    BINDINGS: ClassVar[list[BindingType]] = [
+        Binding("ctrl+c", "cancel", "Cancel", show=False),
+        Binding("escape", "cancel", "Cancel", show=False),
+    ]
+
+    NEXT_SCREEN = "api_key"
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.selected_provider: str = "ollama"
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="provider-selection-outer"):
+            yield NoMarkupStatic("", classes="spacer")
+            yield Center(
+                NoMarkupStatic("Choose your AI provider", id="provider-title")
+            )
+            with Center():
+                with Vertical(id="provider-content"):
+                    yield NoMarkupStatic(
+                        "Select how you want to run codeMaster:",
+                        id="provider-description",
+                    )
+                    yield NoMarkupStatic("", classes="mini-spacer")
+
+                    # Ollama option
+                    yield Button(
+                        "🏠 Local (Ollama) - Free, No API Key",
+                        id="btn-ollama",
+                        variant="primary",
+                    )
+                    yield NoMarkupStatic(
+                        "  → Runs on your machine using Ollama",
+                        classes="provider-hint",
+                    )
+                    yield NoMarkupStatic("", classes="mini-spacer")
+
+                    # Mistral option
+                    yield Button(
+                        "☁️  Cloud (Mistral) - Requires API Key",
+                        id="btn-mistral",
+                        variant="default",
+                    )
+                    yield NoMarkupStatic(
+                        "  → Fast cloud-based AI from Mistral",
+                        classes="provider-hint",
+                    )
+            yield NoMarkupStatic("", classes="spacer")
+
+    def on_mount(self) -> None:
+        self.query_one("#btn-ollama", Button).focus()
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "btn-ollama":
+            self.selected_provider = "ollama"
+            self._configure_and_next("qwen2.5-coder")  # ✅ Supports tools!
+        elif event.button.id == "btn-mistral":
+            self.selected_provider = "mistral"
+            self._configure_and_next("devstral-2")
+
+    def _configure_and_next(self, model_alias: str) -> None:
+        """Save the selected model and proceed to API key screen."""
+        try:
+            VibeConfig.save_updates({"active_model": model_alias})
+        except Exception:
+            pass  # Config will be created during onboarding completion
+
+        # Store selection for API key screen
+        import os
+        os.environ["_CODEMASTER_SELECTED_MODEL"] = model_alias
+
+        self.action_next()

vibe/setup/onboarding/screens/welcome.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+from typing import ClassVar
+
+from textual.app import ComposeResult
+from textual.binding import Binding, BindingType
+from textual.containers import Center, Vertical
+from textual.timer import Timer
+from textual.widgets import Static
+
+from vibe.cli.textual_ui.widgets.no_markup_static import NoMarkupStatic
+from vibe.setup.onboarding.base import OnboardingScreen
+
+WELCOME_PREFIX = "Welcome to "
+WELCOME_HIGHLIGHT = "codeMaster"
+WELCOME_SUFFIX = " - Let's get you started!"
+WELCOME_TEXT = WELCOME_PREFIX + WELCOME_HIGHLIGHT + WELCOME_SUFFIX
+
+HIGHLIGHT_START = len(WELCOME_PREFIX)
+HIGHLIGHT_END = HIGHLIGHT_START + len(WELCOME_HIGHLIGHT)
+
+BUTTON_TEXT = "Press Enter ↵"
+
+GRADIENT_COLORS = [
+    "#ff6b00",
+    "#ff7b00",
+    "#ff8c00",
+    "#ff9d00",
+    "#ffae00",
+    "#ffbf00",
+    "#ffae00",
+    "#ff9d00",
+    "#ff8c00",
+    "#ff7b00",
+]
+
+
+def _apply_gradient(text: str, offset: int) -> str:
+    result = []
+    for i, char in enumerate(text):
+        color = GRADIENT_COLORS[(i + offset) % len(GRADIENT_COLORS)]
+        result.append(f"[bold {color}]{char}[/]")
+    return "".join(result)
+
+
+class WelcomeScreen(OnboardingScreen):
+    BINDINGS: ClassVar[list[BindingType]] = [
+        Binding("enter", "next", "Next", show=False, priority=True),
+        Binding("ctrl+c", "cancel", "Cancel", show=False),
+        Binding("escape", "cancel", "Cancel", show=False),
+    ]
+
+    NEXT_SCREEN = "provider_selection"
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._char_index = 0
+        self._gradient_offset = 0
+        self._typing_done = False
+        self._paused = False
+        self._typing_timer: Timer | None = None
+        self._button_char_index = 0
+        self._button_typing_timer: Timer | None = None
+        self._welcome_text: Static
+        self._enter_hint: Static
+
+    def compose(self) -> ComposeResult:
+        with Vertical(id="welcome-container"):
+            with Center():
+                yield Static("", id="welcome-text")
+            with Center():
+                yield NoMarkupStatic("", id="enter-hint", classes="hidden")
+
+    def on_mount(self) -> None:
+        self._welcome_text = self.query_one("#welcome-text", Static)
+        self._enter_hint = self.query_one("#enter-hint", Static)
+        self._typing_timer = self.set_interval(0.04, self._type_next_char)
+        self.focus()
+
+    def _render_text(self, length: int) -> str:
+        text = WELCOME_TEXT[:length]
+
+        if length <= HIGHLIGHT_START:
+            return text
+
+        prefix = text[:HIGHLIGHT_START]
+        highlight_len = min(length, HIGHLIGHT_END) - HIGHLIGHT_START
+        highlight = _apply_gradient(
+            WELCOME_HIGHLIGHT[:highlight_len], self._gradient_offset
+        )
+
+        if length > HIGHLIGHT_END:
+            suffix = text[HIGHLIGHT_END:]
+            return prefix + highlight + suffix
+        return prefix + highlight
+
+    def _type_next_char(self) -> None:
+        if self._char_index >= len(WELCOME_TEXT):
+            if not self._typing_done:
+                self._typing_done = True
+                self.set_timer(0.5, self._show_button)
+            return
+
+        if self._char_index == HIGHLIGHT_END and not self._paused:
+            self._paused = True
+            if self._typing_timer:
+                self._typing_timer.stop()
+            self.set_interval(0.08, self._animate_gradient)
+            self.set_timer(1.4, self._resume_typing)
+            return
+
+        self._char_index += 1
+        self._welcome_text.update(self._render_text(self._char_index))
+
+    def _resume_typing(self) -> None:
+        self._typing_timer = self.set_interval(0.03, self._type_next_char)
+
+    def _show_button(self) -> None:
+        self._enter_hint.remove_class("hidden")
+        self._button_typing_timer = self.set_interval(0.03, self._type_button_char)
+
+    def _type_button_char(self) -> None:
+        if self._button_char_index >= len(BUTTON_TEXT):
+            if self._button_typing_timer:
+                self._button_typing_timer.stop()
+            return
+        self._button_char_index += 1
+        self._enter_hint.update(BUTTON_TEXT[: self._button_char_index])
+
+    def _animate_gradient(self) -> None:
+        self._gradient_offset = (self._gradient_offset + 1) % len(GRADIENT_COLORS)
+        self._welcome_text.update(self._render_text(self._char_index))
+
+    def action_next(self) -> None:
+        if self._typing_done:
+            super().action_next()

vibe/setup/trusted_folders/trust_folder_dialog.py

@@ -0,0 +1,180 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, ClassVar
+
+from textual import events
+from textual.app import App, ComposeResult
+from textual.binding import Binding, BindingType
+from textual.containers import CenterMiddle, Horizontal
+from textual.message import Message
+from textual.widgets import Static
+
+from vibe.cli.textual_ui.widgets.no_markup_static import NoMarkupStatic
+from vibe.core.paths.global_paths import TRUSTED_FOLDERS_FILE
+
+
+class TrustDialogQuitException(Exception):
+    pass
+
+
+class TrustFolderDialog(CenterMiddle):
+    can_focus = True
+    can_focus_children = True
+
+    BINDINGS: ClassVar[list[BindingType]] = [
+        Binding("left", "move_left", "Left", show=False),
+        Binding("right", "move_right", "Right", show=False),
+        Binding("enter", "select", "Select", show=False),
+        Binding("1", "select_1", "Yes", show=False),
+        Binding("y", "select_1", "Yes", show=False),
+        Binding("2", "select_2", "No", show=False),
+        Binding("n", "select_2", "No", show=False),
+    ]
+
+    class Trusted(Message):
+        pass
+
+    class Untrusted(Message):
+        pass
+
+    def __init__(self, folder_path: Path, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self.folder_path = folder_path
+        self.selected_option = 0
+        self.option_widgets: list[Static] = []
+
+    def compose(self) -> ComposeResult:
+        with CenterMiddle(id="trust-dialog"):
+            yield NoMarkupStatic("⚠ Trust this folder?", id="trust-dialog-title")
+            yield NoMarkupStatic(
+                str(self.folder_path),
+                id="trust-dialog-path",
+                classes="trust-dialog-path",
+            )
+            yield NoMarkupStatic(
+                "Files that can modify your codeMaster setup were found here. Do you trust this folder?",
+                id="trust-dialog-message",
+                classes="trust-dialog-message",
+            )
+
+            with Horizontal(id="trust-options-container"):
+                options = ["Yes", "No"]
+                for idx, text in enumerate(options):
+                    widget = NoMarkupStatic(
+                        f"  {idx + 1}. {text}", classes="trust-option"
+                    )
+                    self.option_widgets.append(widget)
+                    yield widget
+
+            yield NoMarkupStatic(
+                "← → navigate  Enter select", classes="trust-dialog-help"
+            )
+
+            yield NoMarkupStatic(
+                f"Setting will be saved in: {TRUSTED_FOLDERS_FILE.path}",
+                id="trust-dialog-save-info",
+                classes="trust-dialog-save-info",
+            )
+
+    async def on_mount(self) -> None:
+        self.selected_option = 1  # Default to "No"
+        self._update_options()
+        self.focus()
+
+    def _update_options(self) -> None:
+        options = ["Yes", "No"]
+
+        if len(self.option_widgets) != len(options):
+            return
+
+        for idx, (text, widget) in enumerate(
+            zip(options, self.option_widgets, strict=True)
+        ):
+            is_selected = idx == self.selected_option
+
+            cursor = "› " if is_selected else "  "
+            option_text = f"{cursor}{text}"
+
+            widget.update(option_text)
+
+            widget.remove_class("trust-cursor-selected")
+            widget.remove_class("trust-option-selected")
+
+            if is_selected:
+                widget.add_class("trust-cursor-selected")
+            else:
+                widget.add_class("trust-option-selected")
+
+    def action_move_left(self) -> None:
+        self.selected_option = (self.selected_option - 1) % 2
+        self._update_options()
+
+    def action_move_right(self) -> None:
+        self.selected_option = (self.selected_option + 1) % 2
+        self._update_options()
+
+    def action_select(self) -> None:
+        self._handle_selection(self.selected_option)
+
+    def action_select_1(self) -> None:
+        self.selected_option = 0
+        self._handle_selection(0)
+
+    def action_select_2(self) -> None:
+        self.selected_option = 1
+        self._handle_selection(1)
+
+    def _handle_selection(self, option: int) -> None:
+        match option:
+            case 0:
+                self.post_message(self.Trusted())
+            case 1:
+                self.post_message(self.Untrusted())
+
+    def on_blur(self, event: events.Blur) -> None:
+        self.call_after_refresh(self.focus)
+
+
+class TrustFolderApp(App):
+    CSS_PATH = "trust_folder_dialog.tcss"
+
+    BINDINGS: ClassVar[list[BindingType]] = [
+        Binding("ctrl+q", "quit_without_saving", "Quit", show=False, priority=True),
+        Binding("ctrl+c", "quit_without_saving", "Quit", show=False, priority=True),
+    ]
+
+    def __init__(self, folder_path: Path, **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self.folder_path = folder_path
+        self._result: bool | None = None
+        self._quit_without_saving = False
+
+    def on_mount(self) -> None:
+        self.theme = "textual-ansi"
+
+    def compose(self) -> ComposeResult:
+        yield TrustFolderDialog(self.folder_path)
+
+    def action_quit_without_saving(self) -> None:
+        self._quit_without_saving = True
+        self.exit()
+
+    def on_trust_folder_dialog_trusted(self, _: TrustFolderDialog.Trusted) -> None:
+        self._result = True
+        self.exit()
+
+    def on_trust_folder_dialog_untrusted(self, _: TrustFolderDialog.Untrusted) -> None:
+        self._result = False
+        self.exit()
+
+    def run_trust_dialog(self) -> bool | None:
+        self.run()
+        if self._quit_without_saving:
+            raise TrustDialogQuitException()
+        return self._result
+
+
+def ask_trust_folder(folder_path: Path) -> bool | None:
+    app = TrustFolderApp(folder_path)
+    return app.run_trust_dialog()

vibe/setup/trusted_folders/trust_folder_dialog.tcss

@@ -0,0 +1,83 @@
+Screen {
+    align: center middle;
+    background: transparent 80%;
+}
+
+#trust-dialog {
+    width: 70;
+    max-width: 90%;
+    min-width: 50;
+    height: auto;
+    border: round ansi_bright_black;
+    background: transparent;
+    padding: 1;
+}
+
+#trust-dialog-title {
+    width: 100%;
+    height: auto;
+    text-style: bold;
+    color: ansi_yellow;
+    text-align: center;
+    margin-bottom: 1;
+}
+
+#trust-dialog-path {
+    width: 100%;
+    height: auto;
+    color: ansi_blue;
+    text-align: center;
+    text-wrap: wrap;
+    margin-bottom: 1;
+}
+
+#trust-dialog-message {
+    width: 100%;
+    height: auto;
+    color: ansi_default;
+    text-align: center;
+    text-wrap: wrap;
+    margin-bottom: 1;
+}
+
+#trust-options-container {
+    width: 100%;
+    height: auto;
+    align: center middle;
+    margin-bottom: 1;
+}
+
+.trust-option {
+    height: auto;
+    width: auto;
+    color: ansi_default;
+    margin: 0 3;
+    content-align: center middle;
+}
+
+.trust-cursor-selected {
+    color: ansi_default;
+    text-style: bold;
+}
+
+.trust-option-selected {
+    color: ansi_default;
+}
+
+.trust-dialog-help {
+    width: 100%;
+    height: auto;
+    color: ansi_bright_black;
+    text-align: center;
+    margin-bottom: 1;
+}
+
+.trust-dialog-save-info {
+    width: 100%;
+    height: auto;
+    color: ansi_bright_black;
+    text-align: center;
+    text-style: italic;
+    text-wrap: wrap;
+    margin-bottom: 1;
+}

vibe/whats_new.md

@@ -0,0 +1,5 @@
+# What's New in 2.2.0
+
+- **Agent Skills standard** — Vibe now discovers skills from `.agents/skills/` (agentskills.io) as well as `.vibe/skills/`.
+
+Optional: usage and tool events are sent to our datalake to improve the product if you have a valid Mistral API key; set `disable_telemetry = true` in config to opt out.