code-puppy 0.0.332__py3-none-any.whl → 0.0.334__py3-none-any.whl

code_puppy/command_line/onboarding_wizard.py

@@ -0,0 +1,426 @@
+"""Interactive TUI onboarding wizard for first-time Code Puppy users.
+
+🐶 Welcome to Code Puppy! This wizard guides new users through initial setup,
+model configuration, and feature discovery. Uses the same TUI patterns as
+colors_menu.py and diff_menu.py for a consistent experience.
+
+Usage:
+    from code_puppy.command_line.onboarding_wizard import (
+        should_show_onboarding,
+        run_onboarding_wizard,
+    )
+
+    if should_show_onboarding():
+        result = await run_onboarding_wizard()
+        # result: "chatgpt", "claude", "completed", "skipped", or None
+"""
+
+import io
+import os
+import sys
+import time
+from typing import List, Optional, Tuple
+
+from prompt_toolkit import Application
+from prompt_toolkit.formatted_text import ANSI, FormattedText
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.layout import Layout, Window
+from prompt_toolkit.layout.controls import FormattedTextControl
+from prompt_toolkit.widgets import Frame
+from rich.console import Console
+
+from code_puppy.config import CONFIG_DIR
+
+from .onboarding_slides import (
+    MODEL_OPTIONS,
+    slide_agent_system,
+    slide_api_keys,
+    slide_appearance,
+    slide_complete,
+    slide_mcp_servers,
+    slide_model_pinning,
+    slide_model_settings,
+    slide_model_subscription,
+    slide_planning_agent,
+    slide_welcome,
+)
+
+# ============================================================================
+# State Tracking (like motd.py pattern)
+# ============================================================================
+
+ONBOARDING_COMPLETE_FILE = os.path.join(CONFIG_DIR, "onboarding_complete")
+
+
+def has_completed_onboarding() -> bool:
+    """Check if the user has already completed onboarding.
+
+    Returns:
+        True if onboarding has been completed, False otherwise.
+    """
+    return os.path.exists(ONBOARDING_COMPLETE_FILE)
+
+
+def mark_onboarding_complete() -> None:
+    """Mark onboarding as complete by creating the tracking file."""
+    os.makedirs(os.path.dirname(ONBOARDING_COMPLETE_FILE), exist_ok=True)
+    with open(ONBOARDING_COMPLETE_FILE, "w") as f:
+        f.write("completed\n")
+
+
+def should_show_onboarding() -> bool:
+    """Determine if the onboarding wizard should be shown.
+
+    Returns:
+        True if onboarding should be shown, False otherwise.
+    """
+    return not has_completed_onboarding()
+
+
+def reset_onboarding() -> None:
+    """Reset onboarding state (useful for testing or re-running wizard)."""
+    if os.path.exists(ONBOARDING_COMPLETE_FILE):
+        os.remove(ONBOARDING_COMPLETE_FILE)
+
+
+# ============================================================================
+# Onboarding Wizard Class
+# ============================================================================
+
+
+class OnboardingWizard:
+    """Interactive onboarding wizard with slide-based navigation.
+
+    Attributes:
+        current_slide: Index of the currently displayed slide (0-9)
+        selected_option: Index of selected option within current slide
+        trigger_oauth: OAuth provider to trigger after wizard ("chatgpt"/"claude")
+        model_choice: User's model subscription selection
+    """
+
+    TOTAL_SLIDES = 10
+
+    def __init__(self):
+        """Initialize the onboarding wizard state."""
+        self.current_slide = 0
+        self.selected_option = 0
+        self.trigger_oauth: Optional[str] = None
+        self.model_choice: Optional[str] = None
+        self.result: Optional[str] = None
+        self._should_exit = False
+
+    def get_progress_indicator(self) -> str:
+        """Generate progress dots showing current slide position.
+
+        Returns:
+            String like "● ○ ○ ○ ○ ○ ○ ○ ○ ○" for slide 0.
+        """
+        dots = []
+        for i in range(self.TOTAL_SLIDES):
+            if i == self.current_slide:
+                dots.append("●")
+            else:
+                dots.append("○")
+        return " ".join(dots)
+
+    def get_slide_content(self) -> str:
+        """Get combined content for the current slide.
+
+        Returns:
+            Rich markup string for the slide content.
+        """
+        if self.current_slide == 0:
+            return slide_welcome()
+        elif self.current_slide == 1:
+            options = self.get_options_for_slide()
+            return slide_model_subscription(self.selected_option, options)
+        elif self.current_slide == 2:
+            return slide_api_keys(self.model_choice)
+        elif self.current_slide == 3:
+            return slide_mcp_servers()
+        elif self.current_slide == 4:
+            return slide_appearance()
+        elif self.current_slide == 5:
+            return slide_agent_system()
+        elif self.current_slide == 6:
+            return slide_model_pinning()
+        elif self.current_slide == 7:
+            return slide_planning_agent()
+        elif self.current_slide == 8:
+            return slide_model_settings()
+        else:  # slide 9
+            return slide_complete(self.trigger_oauth)
+
+    def get_options_for_slide(self) -> List[Tuple[str, str]]:
+        """Get selectable options for the current slide.
+
+        Returns:
+            List of (id, label) tuples for options, or empty list if no options.
+        """
+        if self.current_slide == 1:  # Model subscription slide
+            return [(opt[0], opt[1]) for opt in MODEL_OPTIONS]
+        return []
+
+    def handle_option_select(self) -> None:
+        """Handle selection of the current option."""
+        if self.current_slide == 1:  # Model subscription
+            options = self.get_options_for_slide()
+            if 0 <= self.selected_option < len(options):
+                choice_id = options[self.selected_option][0]
+                self.model_choice = choice_id
+
+                # Set OAuth trigger for ChatGPT/Claude
+                if choice_id == "chatgpt":
+                    self.trigger_oauth = "chatgpt"
+                elif choice_id == "claude":
+                    self.trigger_oauth = "claude"
+
+    def next_slide(self) -> bool:
+        """Move to the next slide.
+
+        Returns:
+            True if moved to next slide, False if at last slide.
+        """
+        if self.current_slide < self.TOTAL_SLIDES - 1:
+            self.current_slide += 1
+            self.selected_option = 0
+            return True
+        return False
+
+    def prev_slide(self) -> bool:
+        """Move to the previous slide.
+
+        Returns:
+            True if moved to previous slide, False if at first slide.
+        """
+        if self.current_slide > 0:
+            self.current_slide -= 1
+            self.selected_option = 0
+            return True
+        return False
+
+    def next_option(self) -> None:
+        """Move to the next option within the current slide."""
+        options = self.get_options_for_slide()
+        if options:
+            self.selected_option = (self.selected_option + 1) % len(options)
+
+    def prev_option(self) -> None:
+        """Move to the previous option within the current slide."""
+        options = self.get_options_for_slide()
+        if options:
+            self.selected_option = (self.selected_option - 1) % len(options)
+
+
+# ============================================================================
+# TUI Rendering Functions
+# ============================================================================
+
+
+def _get_slide_panel_content(wizard: OnboardingWizard) -> ANSI:
+    """Generate the centered slide content.
+
+    Args:
+        wizard: The OnboardingWizard instance.
+
+    Returns:
+        ANSI object with formatted slide content.
+    """
+    buffer = io.StringIO()
+    console = Console(
+        file=buffer,
+        force_terminal=True,
+        width=80,
+        legacy_windows=False,
+        color_system="truecolor",
+        no_color=False,
+        force_interactive=True,
+    )
+
+    # Progress indicator
+    progress = wizard.get_progress_indicator()
+    console.print(f"[dim]{progress}[/dim]\n")
+
+    # Slide number
+    console.print(
+        f"[dim]Slide {wizard.current_slide + 1} of {wizard.TOTAL_SLIDES}[/dim]\n\n"
+    )
+
+    # Combined slide content
+    slide_content = wizard.get_slide_content()
+    console.print(slide_content)
+
+    return ANSI(buffer.getvalue())
+
+
+def _get_navigation_hints(wizard: OnboardingWizard) -> FormattedText:
+    """Generate navigation hints for the bottom of the screen.
+
+    Args:
+        wizard: The OnboardingWizard instance.
+
+    Returns:
+        FormattedText with navigation hints.
+    """
+    hints = []
+
+    if wizard.current_slide > 0:
+        hints.append(("fg:ansicyan", "← Back  "))
+
+    if wizard.current_slide < wizard.TOTAL_SLIDES - 1:
+        hints.append(("fg:ansicyan", "→ Next  "))
+    else:
+        hints.append(("fg:ansigreen bold", "Enter: Finish  "))
+
+    options = wizard.get_options_for_slide()
+    if options:
+        hints.append(("fg:ansicyan", "↑↓ Options  "))
+
+    hints.append(("fg:ansiyellow", "ESC: Skip"))
+
+    return FormattedText(hints)
+
+
+# ============================================================================
+# Main Entry Point
+# ============================================================================
+
+
+async def run_onboarding_wizard() -> Optional[str]:
+    """Run the interactive onboarding wizard.
+
+    Returns:
+        - "chatgpt" if user wants ChatGPT OAuth
+        - "claude" if user wants Claude OAuth
+        - "completed" if finished normally
+        - "skipped" if user pressed ESC
+        - None on error
+    """
+    from code_puppy.tools.command_runner import set_awaiting_user_input
+
+    wizard = OnboardingWizard()
+
+    set_awaiting_user_input(True)
+
+    # Enter alternate screen buffer
+    sys.stdout.write("\033[?1049h")  # Enter alternate buffer
+    sys.stdout.write("\033[2J\033[H")  # Clear and home
+    sys.stdout.flush()
+    time.sleep(0.1)  # Minimal delay for state sync
+
+    try:
+        # Set up key bindings
+        kb = KeyBindings()
+
+        @kb.add("right")
+        @kb.add("l")
+        def next_slide(event):
+            if wizard.current_slide == wizard.TOTAL_SLIDES - 1:
+                # On last slide, right arrow finishes
+                wizard.result = "completed"
+                wizard._should_exit = True
+                event.app.exit()
+            else:
+                wizard.next_slide()
+            event.app.invalidate()
+
+        @kb.add("left")
+        @kb.add("h")
+        def prev_slide(event):
+            wizard.prev_slide()
+            event.app.invalidate()
+
+        @kb.add("down")
+        @kb.add("j")
+        def next_option(event):
+            wizard.next_option()
+            event.app.invalidate()
+
+        @kb.add("up")
+        @kb.add("k")
+        def prev_option(event):
+            wizard.prev_option()
+            event.app.invalidate()
+
+        @kb.add("enter")
+        def select_or_next(event):
+            # Handle option selection on slides with options
+            options = wizard.get_options_for_slide()
+            if options:
+                wizard.handle_option_select()
+
+            # Move to next slide or finish
+            if wizard.current_slide == wizard.TOTAL_SLIDES - 1:
+                wizard.result = "completed"
+                wizard._should_exit = True
+                event.app.exit()
+            else:
+                wizard.next_slide()
+            event.app.invalidate()
+
+        @kb.add("escape")
+        def skip_wizard(event):
+            wizard.result = "skipped"
+            wizard._should_exit = True
+            event.app.exit()
+
+        @kb.add("c-c")
+        def cancel_wizard(event):
+            wizard.result = "skipped"
+            wizard._should_exit = True
+            event.app.exit()
+
+        # Create layout with single centered panel
+        slide_panel = Window(
+            content=FormattedTextControl(lambda: _get_slide_panel_content(wizard))
+        )
+
+        root_container = Frame(slide_panel, title="🐶 Welcome to Code Puppy!")
+
+        layout = Layout(root_container)
+
+        app = Application(
+            layout=layout,
+            key_bindings=kb,
+            full_screen=False,
+            mouse_support=False,
+            color_depth="DEPTH_24_BIT",
+        )
+
+        # Clear screen before running
+        sys.stdout.write("\033[2J\033[H")
+        sys.stdout.flush()
+
+        # Run the application
+        await app.run_async()
+
+    except KeyboardInterrupt:
+        wizard.result = "skipped"
+    except Exception:
+        wizard.result = None
+    finally:
+        set_awaiting_user_input(False)
+        # Exit alternate screen buffer
+        sys.stdout.write("\033[?1049l")
+        sys.stdout.flush()
+
+    # Mark onboarding as complete (even if skipped - they saw it)
+    if wizard.result in ("completed", "skipped"):
+        mark_onboarding_complete()
+
+    # Return OAuth trigger if selected, otherwise the result
+    if wizard.trigger_oauth:
+        return wizard.trigger_oauth
+
+    return wizard.result
+
+
+async def run_onboarding_if_needed() -> Optional[str]:
+    """Run onboarding wizard if user hasn't completed it yet.
+
+    Returns:
+        Result from run_onboarding_wizard() or None if not needed.
+    """
+    if should_show_onboarding():
+        return await run_onboarding_wizard()
+    return None

code_puppy/config.py

@@ -1051,11 +1051,11 @@ def set_enable_dbos(enabled: bool) -> None:
     set_config_value("enable_dbos", "true" if enabled else "false")
 
 
-def get_message_limit(default: int = 100) -> int:
+def get_message_limit(default: int = 1000) -> int:
     """
     Returns the user-configured message/request limit for the agent.
     This controls how many steps/requests the agent can take.
-    Defaults to 100 if unset or misconfigured.
+    Defaults to 1000 if unset or misconfigured.
     Configurable by 'message_limit' key.
     """
     val = get_value("message_limit")

code_puppy/keymap.py

@@ -55,11 +55,19 @@ class KeymapError(Exception):
 def get_cancel_agent_key() -> str:
     """Get the configured cancel agent key from config.
 
+    On Windows when launched via uvx, this automatically returns "ctrl+k"
+    to work around uvx capturing Ctrl+C before it reaches Python.
+
     Returns:
         The key name (e.g., "ctrl+c", "ctrl+k") from config,
         or the default if not configured.
     """
     from code_puppy.config import get_value
+    from code_puppy.uvx_detection import should_use_alternate_cancel_key
+
+    # On Windows + uvx, force ctrl+k to bypass uvx's SIGINT capture
+    if should_use_alternate_cancel_key():
+        return "ctrl+k"
 
     key = get_value("cancel_agent_key")
     if key is None or key.strip() == "":

code_puppy/plugins/chatgpt_oauth/register_callbacks.py

@@ -6,6 +6,7 @@ import os
 from typing import List, Optional, Tuple
 
 from code_puppy.callbacks import register_callback
+from code_puppy.config import set_model_name
 from code_puppy.messaging import emit_info, emit_success, emit_warning
 
 from .config import CHATGPT_OAUTH_CONFIG, get_token_storage_path
@@ -75,6 +76,7 @@ def _handle_custom_command(command: str, name: str) -> Optional[bool]:
 
     if name == "chatgpt-auth":
         run_oauth_flow()
+        set_model_name("chatgpt-gpt-5.2-codex")
         return True
 
     if name == "chatgpt-status":

code_puppy/plugins/claude_code_oauth/register_callbacks.py

@@ -12,6 +12,7 @@ from typing import Any, Dict, List, Optional, Tuple
 from urllib.parse import parse_qs, urlparse
 
 from code_puppy.callbacks import register_callback
+from code_puppy.config import set_model_name
 from code_puppy.messaging import emit_error, emit_info, emit_success, emit_warning
 
 from ..oauth_puppy_html import oauth_failure_html, oauth_success_html
@@ -260,6 +261,7 @@ def _handle_custom_command(command: str, name: str) -> Optional[bool]:
                 "Existing Claude Code tokens found. Continuing will overwrite them."
             )
         _perform_authentication()
+        set_model_name("claude-code-claude-opus-4-5-20251101")
         return True
 
     if name == "claude-code-status":

code_puppy/terminal_utils.py

@@ -6,6 +6,10 @@ Handles Windows console mode resets and Unix terminal sanity restoration.
 import platform
 import subprocess
 import sys
+from typing import Callable, Optional
+
+# Store the original console ctrl handler so we can restore it if needed
+_original_ctrl_handler: Optional[Callable] = None
 
 
 def reset_windows_terminal_ansi() -> None:
@@ -86,21 +90,36 @@ def reset_windows_console_mode() -> None:
         pass  # Silently ignore errors - best effort reset
 
 
-def reset_windows_terminal_full() -> None:
-    """Perform a full Windows terminal reset (console mode + ANSI).
+def flush_windows_keyboard_buffer() -> None:
+    """Flush the Windows keyboard buffer.
 
-    Combines both console mode reset and ANSI reset for complete
-    terminal state restoration after interrupts.
+    Clears any pending keyboard input that could interfere with
+    subsequent input operations after an interrupt.
+    """
+    if platform.system() != "Windows":
+        return
 
-    IMPORTANT: Console mode must be reset FIRST to re-enable
-    ENABLE_VIRTUAL_TERMINAL_PROCESSING, otherwise the ANSI escape
-    sequences will be printed as literal text (e.g., '[0m').
+    try:
+        import msvcrt
+
+        while msvcrt.kbhit():
+            msvcrt.getch()
+    except Exception:
+        pass  # Silently ignore errors - best effort flush
+
+
+def reset_windows_terminal_full() -> None:
+    """Perform a full Windows terminal reset (ANSI + console mode + keyboard buffer).
+
+    Combines ANSI reset, console mode reset, and keyboard buffer flush
+    for complete terminal state restoration after interrupts.
     """
     if platform.system() != "Windows":
         return
 
-    reset_windows_console_mode()  # Must be first! Enables ANSI processing
-    reset_windows_terminal_ansi()  # Now ANSI escapes will be interpreted
+    reset_windows_terminal_ansi()
+    reset_windows_console_mode()
+    flush_windows_keyboard_buffer()
 
 
 def reset_unix_terminal() -> None:
@@ -128,3 +147,145 @@ def reset_terminal() -> None:
         reset_windows_terminal_full()
     else:
         reset_unix_terminal()
+
+
+def disable_windows_ctrl_c() -> bool:
+    """Disable Ctrl+C processing at the Windows console input level.
+
+    This removes ENABLE_PROCESSED_INPUT from stdin, which prevents
+    Ctrl+C from being interpreted as a signal at all. Instead, it
+    becomes just a regular character (^C) that gets ignored.
+
+    This is more reliable than SetConsoleCtrlHandler because it
+    prevents Ctrl+C from being processed before it reaches any handler.
+
+    Returns:
+        True if successfully disabled, False otherwise.
+    """
+    global _original_ctrl_handler
+
+    if platform.system() != "Windows":
+        return False
+
+    try:
+        import ctypes
+
+        kernel32 = ctypes.windll.kernel32
+
+        # Get stdin handle
+        STD_INPUT_HANDLE = -10
+        stdin_handle = kernel32.GetStdHandle(STD_INPUT_HANDLE)
+
+        # Get current console mode
+        mode = ctypes.c_ulong()
+        if not kernel32.GetConsoleMode(stdin_handle, ctypes.byref(mode)):
+            return False
+
+        # Save original mode for potential restoration
+        _original_ctrl_handler = mode.value
+
+        # Console mode flags
+        ENABLE_PROCESSED_INPUT = 0x0001  # This makes Ctrl+C generate signals
+
+        # Remove ENABLE_PROCESSED_INPUT to disable Ctrl+C signal generation
+        new_mode = mode.value & ~ENABLE_PROCESSED_INPUT
+
+        if kernel32.SetConsoleMode(stdin_handle, new_mode):
+            return True
+        return False
+
+    except Exception:
+        return False
+
+
+def enable_windows_ctrl_c() -> bool:
+    """Re-enable Ctrl+C at the Windows console level.
+
+    Restores the original console mode saved by disable_windows_ctrl_c().
+
+    Returns:
+        True if successfully re-enabled, False otherwise.
+    """
+    global _original_ctrl_handler
+
+    if platform.system() != "Windows":
+        return False
+
+    if _original_ctrl_handler is None:
+        return True  # Nothing to restore
+
+    try:
+        import ctypes
+
+        kernel32 = ctypes.windll.kernel32
+
+        # Get stdin handle
+        STD_INPUT_HANDLE = -10
+        stdin_handle = kernel32.GetStdHandle(STD_INPUT_HANDLE)
+
+        # Restore original mode
+        if kernel32.SetConsoleMode(stdin_handle, _original_ctrl_handler):
+            _original_ctrl_handler = None
+            return True
+        return False
+
+    except Exception:
+        return False
+
+
+# Flag to track if we should keep Ctrl+C disabled
+_keep_ctrl_c_disabled: bool = False
+
+
+def set_keep_ctrl_c_disabled(value: bool) -> None:
+    """Set whether Ctrl+C should be kept disabled.
+
+    When True, ensure_ctrl_c_disabled() will re-disable Ctrl+C
+    even if something else (like prompt_toolkit) re-enables it.
+    """
+    global _keep_ctrl_c_disabled
+    _keep_ctrl_c_disabled = value
+
+
+def ensure_ctrl_c_disabled() -> bool:
+    """Ensure Ctrl+C is disabled if it should be.
+
+    Call this after operations that might restore console mode
+    (like prompt_toolkit input).
+
+    Returns:
+        True if Ctrl+C is now disabled (or wasn't needed), False on error.
+    """
+    if not _keep_ctrl_c_disabled:
+        return True
+
+    if platform.system() != "Windows":
+        return True
+
+    try:
+        import ctypes
+
+        kernel32 = ctypes.windll.kernel32
+
+        # Get stdin handle
+        STD_INPUT_HANDLE = -10
+        stdin_handle = kernel32.GetStdHandle(STD_INPUT_HANDLE)
+
+        # Get current console mode
+        mode = ctypes.c_ulong()
+        if not kernel32.GetConsoleMode(stdin_handle, ctypes.byref(mode)):
+            return False
+
+        # Console mode flags
+        ENABLE_PROCESSED_INPUT = 0x0001
+
+        # Check if Ctrl+C processing is enabled
+        if mode.value & ENABLE_PROCESSED_INPUT:
+            # Disable it
+            new_mode = mode.value & ~ENABLE_PROCESSED_INPUT
+            return bool(kernel32.SetConsoleMode(stdin_handle, new_mode))
+
+        return True  # Already disabled
+
+    except Exception:
+        return False