shotgun-sh 0.2.11.dev1__py3-none-any.whl → 0.2.11.dev5__py3-none-any.whl

shotgun/tui/app.py

@@ -5,6 +5,7 @@ from textual.app import App, SystemCommand
 from textual.binding import Binding
 from textual.screen import Screen
 
+from shotgun.agents.agent_manager import AgentManager
 from shotgun.agents.config import ConfigManager, get_config_manager
 from shotgun.agents.models import AgentType
 from shotgun.logging_config import get_logger
@@ -18,7 +19,7 @@ from shotgun.utils.update_checker import (
 
 from .screens.chat import ChatScreen
 from .screens.directory_setup import DirectorySetupScreen
-from .screens.feedback import FeedbackScreen
+from .screens.github_issue import GitHubIssueScreen
 from .screens.model_picker import ModelPickerScreen
 from .screens.pipx_migration import PipxMigrationScreen
 from .screens.provider_config import ProviderConfigScreen
@@ -34,7 +35,7 @@ class ShotgunApp(App[None]):
         "provider_config": ProviderConfigScreen,
         "model_picker": ModelPickerScreen,
         "directory_setup": DirectorySetupScreen,
-        "feedback": FeedbackScreen,
+        "github_issue": GitHubIssueScreen,
     }
     BINDINGS = [
         Binding("ctrl+c", "quit", "Quit the app"),
@@ -95,65 +96,75 @@ class ShotgunApp(App[None]):
                 )
                 return
 
-        # Show welcome screen if no providers are configured OR if user hasn't seen it yet
-        config = self.config_manager.load()
-        if (
-            not self.config_manager.has_any_provider_key()
-            or not config.shown_welcome_screen
-        ):
-            if isinstance(self.screen, WelcomeScreen):
+        # Run async config loading in worker
+        async def _check_config() -> None:
+            # Show welcome screen if no providers are configured OR if user hasn't seen it yet
+            config = await self.config_manager.load()
+            has_any_key = await self.config_manager.has_any_provider_key()
+            if not has_any_key or not config.shown_welcome_screen:
+                if isinstance(self.screen, WelcomeScreen):
+                    return
+
+                self.push_screen(
+                    WelcomeScreen(),
+                    callback=lambda _arg: self.refresh_startup_screen(),
+                )
                 return
 
-            self.push_screen(
-                WelcomeScreen(),
-                callback=lambda _arg: self.refresh_startup_screen(),
-            )
-            return
+            if not self.check_local_shotgun_directory_exists():
+                if isinstance(self.screen, DirectorySetupScreen):
+                    return
+
+                self.push_screen(
+                    DirectorySetupScreen(),
+                    callback=lambda _arg: self.refresh_startup_screen(),
+                )
+                return
 
-        if not self.check_local_shotgun_directory_exists():
-            if isinstance(self.screen, DirectorySetupScreen):
+            if isinstance(self.screen, ChatScreen):
                 return
 
-            self.push_screen(
-                DirectorySetupScreen(),
-                callback=lambda _arg: self.refresh_startup_screen(),
+            # Create ChatScreen with all dependencies injected from container
+            # Get the default agent mode (RESEARCH)
+            agent_mode = AgentType.RESEARCH
+
+            # Create AgentDeps asynchronously (get_provider_model is now async)
+            from shotgun.tui.dependencies import create_default_tui_deps
+
+            agent_deps = await create_default_tui_deps()
+
+            # Create AgentManager with async initialization
+            agent_manager = AgentManager(deps=agent_deps, initial_type=agent_mode)
+
+            # Create ProcessingStateManager - we'll pass the screen after creation
+            # For now, create with None and the ChatScreen will set itself
+            chat_screen = ChatScreen(
+                agent_manager=agent_manager,
+                conversation_manager=self.container.conversation_manager(),
+                conversation_service=self.container.conversation_service(),
+                widget_coordinator=self.container.widget_coordinator_factory(
+                    screen=None
+                ),
+                processing_state=self.container.processing_state_factory(
+                    screen=None,  # Will be set after ChatScreen is created
+                    telemetry_context={"agent_mode": agent_mode.value},
+                ),
+                command_handler=self.container.command_handler(),
+                placeholder_hints=self.container.placeholder_hints(),
+                codebase_sdk=self.container.codebase_sdk(),
+                deps=agent_deps,
+                continue_session=self.continue_session,
+                force_reindex=self.force_reindex,
             )
-            return
-
-        if isinstance(self.screen, ChatScreen):
-            return
-
-        # Create ChatScreen with all dependencies injected from container
-        # Get the default agent mode (RESEARCH)
-        agent_mode = AgentType.RESEARCH
-
-        # Create AgentManager with the correct mode
-        agent_manager = self.container.agent_manager_factory(initial_type=agent_mode)
-
-        # Create ProcessingStateManager - we'll pass the screen after creation
-        # For now, create with None and the ChatScreen will set itself
-        chat_screen = ChatScreen(
-            agent_manager=agent_manager,
-            conversation_manager=self.container.conversation_manager(),
-            conversation_service=self.container.conversation_service(),
-            widget_coordinator=self.container.widget_coordinator_factory(screen=None),
-            processing_state=self.container.processing_state_factory(
-                screen=None,  # Will be set after ChatScreen is created
-                telemetry_context={"agent_mode": agent_mode.value},
-            ),
-            command_handler=self.container.command_handler(),
-            placeholder_hints=self.container.placeholder_hints(),
-            codebase_sdk=self.container.codebase_sdk(),
-            deps=self.container.agent_deps(),
-            continue_session=self.continue_session,
-            force_reindex=self.force_reindex,
-        )
 
-        # Update the ProcessingStateManager and WidgetCoordinator with the actual ChatScreen instance
-        chat_screen.processing_state.screen = chat_screen
-        chat_screen.widget_coordinator.screen = chat_screen
+            # Update the ProcessingStateManager and WidgetCoordinator with the actual ChatScreen instance
+            chat_screen.processing_state.screen = chat_screen
+            chat_screen.widget_coordinator.screen = chat_screen
 
-        self.push_screen(chat_screen)
+            self.push_screen(chat_screen)
+
+        # Run the async config check in a worker
+        self.run_worker(_check_config(), exclusive=False)
 
     def check_local_shotgun_directory_exists(self) -> bool:
         shotgun_dir = get_shotgun_base_path()
@@ -170,20 +181,15 @@ class ShotgunApp(App[None]):
     def get_system_commands(self, screen: Screen[Any]) -> Iterable[SystemCommand]:
         return [
             SystemCommand(
-                "Feedback", "Send us feedback or report a bug", self.action_feedback
+                "New Issue",
+                "Report a bug or request a feature on GitHub",
+                self.action_new_issue,
             )
-        ]  # we don't want any system commands
-
-    def action_feedback(self) -> None:
-        """Open feedback screen and submit feedback."""
-        from shotgun.posthog_telemetry import Feedback, submit_feedback_survey
-
-        def handle_feedback(feedback: Feedback | None) -> None:
-            if feedback is not None:
-                submit_feedback_survey(feedback)
-                self.notify("Feedback sent. Thank you!")
+        ]
 
-        self.push_screen(FeedbackScreen(), callback=handle_feedback)
+    def action_new_issue(self) -> None:
+        """Open GitHub issue screen to guide users to create an issue."""
+        self.push_screen(GitHubIssueScreen())
 
 
 def run(

shotgun/tui/components/context_indicator.py

@@ -1,6 +1,7 @@
 """Context window indicator component for showing model usage."""
 
 from textual.reactive import reactive
+from textual.timer import Timer
 from textual.widgets import Static
 
 from shotgun.agents.config.models import MODEL_SPECS, ModelName
@@ -20,6 +21,10 @@ class ContextIndicator(Static):
 
     context_analysis: reactive[ContextAnalysis | None] = reactive(None)
     model_name: reactive[ModelName | None] = reactive(None)
+    is_streaming: reactive[bool] = reactive(False)
+
+    _animation_frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+    _animation_index = 0
 
     def __init__(
         self,
@@ -29,6 +34,7 @@ class ContextIndicator(Static):
         classes: str | None = None,
     ) -> None:
         super().__init__(name=name, id=id, classes=classes)
+        self._animation_timer: Timer | None = None
 
     def update_context(
         self, analysis: ContextAnalysis | None, model: ModelName | None
@@ -43,6 +49,38 @@ class ContextIndicator(Static):
         self.model_name = model
         self._refresh_display()
 
+    def set_streaming(self, streaming: bool) -> None:
+        """Enable or disable streaming animation.
+
+        Args:
+            streaming: Whether to show streaming animation
+        """
+        self.is_streaming = streaming
+        if streaming:
+            self._start_animation()
+        else:
+            self._stop_animation()
+
+    def _start_animation(self) -> None:
+        """Start the pulsing animation."""
+        if self._animation_timer is None:
+            self._animation_timer = self.set_interval(0.1, self._animate_frame)
+
+    def _stop_animation(self) -> None:
+        """Stop the pulsing animation."""
+        if self._animation_timer is not None:
+            self._animation_timer.stop()
+            self._animation_timer = None
+        self._animation_index = 0
+        self._refresh_display()
+
+    def _animate_frame(self) -> None:
+        """Advance the animation frame."""
+        self._animation_index = (self._animation_index + 1) % len(
+            self._animation_frames
+        )
+        self._refresh_display()
+
     def _get_percentage_color(self, percentage: float) -> str:
         """Get color for percentage based on threshold.
 
@@ -112,6 +150,11 @@ class ContextIndicator(Static):
             f"[{color}]{percentage}% ({current_tokens}/{max_tokens})[/]",
         ]
 
+        # Add streaming animation indicator if streaming
+        if self.is_streaming:
+            animation_char = self._animation_frames[self._animation_index]
+            parts.append(f"[bold cyan]{animation_char}[/]")
+
         # Add model name if available
         if self.model_name:
             model_spec = MODEL_SPECS.get(self.model_name)

shotgun/tui/containers.py

@@ -5,10 +5,8 @@ from typing import TYPE_CHECKING
 from dependency_injector import containers, providers
 from pydantic_ai import RunContext
 
-from shotgun.agents.agent_manager import AgentManager
-from shotgun.agents.config import get_provider_model
 from shotgun.agents.conversation_manager import ConversationManager
-from shotgun.agents.models import AgentDeps, AgentType
+from shotgun.agents.models import AgentDeps
 from shotgun.sdk.codebase import CodebaseSDK
 from shotgun.tui.commands import CommandHandler
 from shotgun.tui.filtered_codebase_service import FilteredCodebaseService
@@ -35,13 +33,19 @@ class TUIContainer(containers.DeclarativeContainer):
 
     This container manages the lifecycle and dependencies of all TUI components,
     ensuring consistent configuration and facilitating testing.
+
+    Note: model_config and agent_deps are created lazily via async factory methods
+    since get_provider_model() is now async.
     """
 
     # Configuration
     config = providers.Configuration()
 
     # Core dependencies
-    model_config = providers.Singleton(get_provider_model)
+    # TODO: Figure out a better solution for async dependency injection
+    # model_config is now loaded lazily via create_default_tui_deps()
+    # because get_provider_model() is async. This breaks the DI pattern
+    # and should be refactored to support async factories properly.
 
     storage_dir = providers.Singleton(lambda: get_shotgun_home() / "codebases")
 
@@ -51,15 +55,10 @@ class TUIContainer(containers.DeclarativeContainer):
 
     system_prompt_fn = providers.Object(_placeholder_system_prompt)
 
-    # AgentDeps singleton
-    agent_deps = providers.Singleton(
-        AgentDeps,
-        interactive_mode=True,
-        is_tui_context=True,
-        llm_model=model_config,
-        codebase_service=codebase_service,
-        system_prompt_fn=system_prompt_fn,
-    )
+    # TODO: Figure out a better solution for async dependency injection
+    # AgentDeps is now created via async create_default_tui_deps()
+    # instead of using DI container's Singleton provider because it requires
+    # async model_config initialization
 
     # Service singletons
     codebase_sdk = providers.Singleton(CodebaseSDK)
@@ -74,10 +73,9 @@ class TUIContainer(containers.DeclarativeContainer):
         ConversationService, conversation_manager=conversation_manager
     )
 
-    # Factory for AgentManager (needs agent_type parameter)
-    agent_manager_factory = providers.Factory(
-        AgentManager, deps=agent_deps, initial_type=providers.Object(AgentType.RESEARCH)
-    )
+    # TODO: Figure out a better solution for async dependency injection
+    # AgentManager factory removed - create via async initialization
+    # since it requires async agent creation
 
     # Factory for ProcessingStateManager (needs ChatScreen reference)
     processing_state_factory = providers.Factory(

shotgun/tui/dependencies.py

@@ -8,7 +8,7 @@ from shotgun.tui.filtered_codebase_service import FilteredCodebaseService
 from shotgun.utils import get_shotgun_home
 
 
-def create_default_tui_deps() -> AgentDeps:
+async def create_default_tui_deps() -> AgentDeps:
     """Create default AgentDeps for TUI components.
 
     This creates a standard AgentDeps configuration suitable for interactive
@@ -21,7 +21,7 @@ def create_default_tui_deps() -> AgentDeps:
     Returns:
         Configured AgentDeps instance ready for TUI use.
     """
-    model_config = get_provider_model()
+    model_config = await get_provider_model()
     storage_dir = get_shotgun_home() / "codebases"
     codebase_service = FilteredCodebaseService(storage_dir)
 

shotgun/tui/screens/chat/chat_screen.py

@@ -2,6 +2,7 @@
 
 import asyncio
 import logging
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import cast
 
@@ -31,6 +32,7 @@ from shotgun.agents.agent_manager import (
     ModelConfigUpdated,
     PartialResponseMessage,
 )
+from shotgun.agents.config import get_config_manager
 from shotgun.agents.config.models import MODEL_SPECS
 from shotgun.agents.conversation_manager import ConversationManager
 from shotgun.agents.history.compaction import apply_persistent_compaction
@@ -70,11 +72,13 @@ from shotgun.tui.screens.chat_screen.command_providers import (
 from shotgun.tui.screens.chat_screen.hint_message import HintMessage
 from shotgun.tui.screens.chat_screen.history import ChatHistory
 from shotgun.tui.screens.confirmation_dialog import ConfirmationDialog
+from shotgun.tui.screens.onboarding import OnboardingModal
 from shotgun.tui.services.conversation_service import ConversationService
 from shotgun.tui.state.processing_state import ProcessingStateManager
 from shotgun.tui.utils.mode_progress import PlaceholderHints
 from shotgun.tui.widgets.widget_coordinator import WidgetCoordinator
 from shotgun.utils import get_shotgun_home
+from shotgun.utils.marketing import MarketingManager
 
 logger = logging.getLogger(__name__)
 
@@ -165,13 +169,17 @@ class ChatScreen(Screen[None]):
         self.processing_state.bind_spinner(self.query_one("#spinner", Spinner))
 
         # Load conversation history if --continue flag was provided
-        if self.continue_session and self.conversation_manager.exists():
-            self._load_conversation()
+        # Use call_later to handle async exists() check
+        if self.continue_session:
+            self.call_later(self._check_and_load_conversation)
 
         self.call_later(self.check_if_codebase_is_indexed)
         # Initial update of context indicator
         self.update_context_indicator()
 
+        # Show onboarding popup if not shown before
+        self.call_later(self._check_and_show_onboarding)
+
     async def on_key(self, event: events.Key) -> None:
         """Handle key presses for cancellation."""
         # If escape is pressed during Q&A mode, exit Q&A
@@ -304,6 +312,10 @@ class ChatScreen(Screen[None]):
         else:
             self.notify("No context analysis available", severity="error")
 
+    def action_view_onboarding(self) -> None:
+        """Show the onboarding modal."""
+        self.app.push_screen(OnboardingModal())
+
     @work
     async def action_compact_conversation(self) -> None:
         """Compact the conversation history to reduce size."""
@@ -386,11 +398,11 @@ class ChatScreen(Screen[None]):
             # Save to conversation file
             conversation_file = get_shotgun_home() / "conversation.json"
             manager = ConversationManager(conversation_file)
-            conversation = manager.load()
+            conversation = await manager.load()
 
             if conversation:
                 conversation.set_agent_messages(compacted_messages)
-                manager.save(conversation)
+                await manager.save(conversation)
 
             # Post compaction completed event
             self.agent_manager.post_message(CompactionCompletedMessage())
@@ -455,7 +467,7 @@ class ChatScreen(Screen[None]):
             self.agent_manager.ui_message_history = []
 
             # Use conversation service to clear conversation
-            self.conversation_service.clear_conversation()
+            await self.conversation_service.clear_conversation()
 
             # Post message history updated event to refresh UI
             self.agent_manager.post_message(
@@ -502,6 +514,34 @@ class ChatScreen(Screen[None]):
                 f"[CONTEXT] Failed to update context indicator: {e}", exc_info=True
             )
 
+    @work(exclusive=False)
+    async def update_context_indicator_with_messages(
+        self,
+        agent_messages: list[ModelMessage],
+        ui_messages: list[ModelMessage | HintMessage],
+    ) -> None:
+        """Update the context indicator with specific message sets (for streaming updates).
+
+        Args:
+            agent_messages: Agent message history including streaming messages (for token counting)
+            ui_messages: UI message history including hints and streaming messages
+        """
+        try:
+            from shotgun.agents.context_analyzer.analyzer import ContextAnalyzer
+
+            analyzer = ContextAnalyzer(self.deps.llm_model)
+            # Analyze the combined message histories for accurate progressive token counts
+            analysis = await analyzer.analyze_conversation(agent_messages, ui_messages)
+
+            if analysis:
+                model_name = self.deps.llm_model.name
+                self.widget_coordinator.update_context_indicator(analysis, model_name)
+        except Exception as e:
+            logger.error(
+                f"Failed to update context indicator with streaming messages: {e}",
+                exc_info=True,
+            )
+
     def compose(self) -> ComposeResult:
         """Create child widgets for the app."""
         with Container(id="window"):
@@ -551,7 +591,7 @@ class ChatScreen(Screen[None]):
                 # Keep all ModelResponse and other message types
                 filtered_event_messages.append(msg)
 
-        # Build new message list
+        # Build new message list combining existing messages with new streaming content
         new_message_list = self.messages + cast(
             list[ModelMessage | HintMessage], filtered_event_messages
         )
@@ -561,6 +601,13 @@ class ChatScreen(Screen[None]):
             self.partial_message, new_message_list
         )
 
+        # Update context indicator with full message history including streaming messages
+        # Combine existing agent history with new streaming messages for accurate token count
+        combined_agent_history = self.agent_manager.message_history + event.messages
+        self.update_context_indicator_with_messages(
+            combined_agent_history, new_message_list
+        )
+
     def _clear_partial_response(self) -> None:
         # Use widget coordinator to clear partial response
         self.widget_coordinator.set_partial_response(None, self.messages)
@@ -602,7 +649,9 @@ class ChatScreen(Screen[None]):
         self.qa_answers = []
 
     @on(MessageHistoryUpdated)
-    def handle_message_history_updated(self, event: MessageHistoryUpdated) -> None:
+    async def handle_message_history_updated(
+        self, event: MessageHistoryUpdated
+    ) -> None:
         """Handle message history updates from the agent manager."""
         self._clear_partial_response()
         self.messages = event.messages
@@ -644,6 +693,14 @@ class ChatScreen(Screen[None]):
 
                     self.mount_hint(message)
 
+                    # Check and display any marketing messages
+                    from shotgun.tui.app import ShotgunApp
+
+                    app = cast(ShotgunApp, self.app)
+                    await MarketingManager.check_and_display_messages(
+                        app.config_manager, event.file_operations, self.mount_hint
+                    )
+
     @on(CompactionStartedMessage)
     def handle_compaction_started(self, event: CompactionStartedMessage) -> None:
         """Update spinner text when compaction starts."""
@@ -1048,6 +1105,9 @@ class ChatScreen(Screen[None]):
         self.processing_state.start_processing("Processing...")
         self.processing_state.bind_worker(get_current_worker())
 
+        # Start context indicator animation immediately
+        self.widget_coordinator.set_context_streaming(True)
+
         prompt = message
 
         try:
@@ -1083,6 +1143,8 @@ class ChatScreen(Screen[None]):
             self.mount_hint(hint)
         finally:
             self.processing_state.stop_processing()
+            # Stop context indicator animation
+            self.widget_coordinator.set_context_streaming(False)
 
         # Save conversation after each interaction
         self._save_conversation()
@@ -1091,20 +1153,50 @@ class ChatScreen(Screen[None]):
 
     def _save_conversation(self) -> None:
         """Save the current conversation to persistent storage."""
-        # Use conversation service for saving
-        self.conversation_service.save_conversation(self.agent_manager)
+        # Use conversation service for saving (run async in background)
+        # Use exclusive=True to prevent concurrent saves that can cause file contention
+        self.run_worker(
+            self.conversation_service.save_conversation(self.agent_manager),
+            exclusive=True,
+        )
+
+    async def _check_and_load_conversation(self) -> None:
+        """Check if conversation exists and load it if it does."""
+        if await self.conversation_manager.exists():
+            self._load_conversation()
 
     def _load_conversation(self) -> None:
         """Load conversation from persistent storage."""
-        # Use conversation service for restoration
-        success, error_msg, restored_type = (
-            self.conversation_service.restore_conversation(
+
+        # Use conversation service for restoration (run async)
+        async def _do_load() -> None:
+            (
+                success,
+                error_msg,
+                restored_type,
+            ) = await self.conversation_service.restore_conversation(
                 self.agent_manager, self.deps.usage_manager
             )
-        )
 
-        if not success and error_msg:
-            self.mount_hint(error_msg)
-        elif success and restored_type:
-            # Update the current mode to match restored conversation
-            self.mode = restored_type
+            if not success and error_msg:
+                self.mount_hint(error_msg)
+            elif success and restored_type:
+                # Update the current mode to match restored conversation
+                self.mode = restored_type
+
+        self.run_worker(_do_load(), exclusive=False)
+
+    @work
+    async def _check_and_show_onboarding(self) -> None:
+        """Check if onboarding should be shown and display modal if needed."""
+        config_manager = get_config_manager()
+        config = await config_manager.load()
+
+        # Only show onboarding if it hasn't been shown before
+        if config.shown_onboarding_popup is None:
+            # Show the onboarding modal
+            await self.app.push_screen_wait(OnboardingModal())
+
+            # Mark as shown in config with current timestamp
+            config.shown_onboarding_popup = datetime.now(timezone.utc)
+            await config_manager.save(config)

shotgun/tui/screens/chat/help_text.py

@@ -11,14 +11,14 @@ def help_text_with_codebase(already_indexed: bool = False) -> str:
         Formatted help text string.
     """
     return (
-        "Howdy! Welcome to Shotgun - the context tool for software engineering. \n\n"
-        "You can research, build specs, plan, create tasks, and export context to your "
-        "favorite code-gen agents.\n\n"
-        f"{'' if already_indexed else 'Once your codebase is indexed, '}I can help with:\n\n"
-        "- Speccing out a new feature\n"
-        "- Onboarding you onto this project\n"
-        "- Helping with a refactor spec\n"
-        "- Creating AGENTS.md file for this project\n"
+        "Howdy! Welcome to Shotgun - Spec Driven Development for Developers and AI Agents.\n\n"
+        "Shotgun writes codebase-aware specs for your AI coding agents so they don't derail.\n\n"
+        f"{'It' if already_indexed else 'Once your codebase is indexed, it'} can help you:\n"
+        "- Research your codebase and spec out new features\n"
+        "- Create implementation plans that fit your architecture\n"
+        "- Generate AGENTS.md files for AI coding agents\n"
+        "- Onboard to existing projects or plan refactors\n\n"
+        "Ready to build something? Let's go.\n"
     )
 
 
@@ -29,11 +29,12 @@ def help_text_empty_dir() -> str:
         Formatted help text string.
     """
     return (
-        "Howdy! Welcome to Shotgun - the context tool for software engineering.\n\n"
-        "You can research, build specs, plan, create tasks, and export context to your "
-        "favorite code-gen agents.\n\n"
-        "What would you like to build? Here are some examples:\n\n"
-        "- Research FastAPI vs Django\n"
-        "- Plan my new web app using React\n"
-        "- Create PRD for my planned product\n"
+        "Howdy! Welcome to Shotgun - Spec Driven Development for Developers and AI Agents.\n\n"
+        "Shotgun writes codebase-aware specs for your AI coding agents so they don't derail.\n\n"
+        "It can help you:\n"
+        "- Research your codebase and spec out new features\n"
+        "- Create implementation plans that fit your architecture\n"
+        "- Generate AGENTS.md files for AI coding agents\n"
+        "- Onboard to existing projects or plan refactors\n\n"
+        "Ready to build something? Let's go.\n"
     )

shotgun/tui/screens/chat_screen/command_providers.py

@@ -369,6 +369,11 @@ class UnifiedCommandProvider(Provider):
             self.chat_screen.action_show_usage,
             help="Display usage information for the current session",
         )
+        yield DiscoveryHit(
+            "View Onboarding",
+            self.chat_screen.action_view_onboarding,
+            help="View the onboarding tutorial and helpful resources",
+        )
 
     async def search(self, query: str) -> AsyncGenerator[Hit, None]:
         """Search for commands in alphabetical order."""
@@ -416,6 +421,11 @@ class UnifiedCommandProvider(Provider):
                 self.chat_screen.action_show_usage,
                 "Display usage information for the current session",
             ),
+            (
+                "View Onboarding",
+                self.chat_screen.action_view_onboarding,
+                "View the onboarding tutorial and helpful resources",
+            ),
         ]
 
         for title, callback, help_text in commands: