feat(cli): add no-user-skills flag to AgentContext

openhands_cli/agent_chat.py

@@ -65,27 +65,23 @@ def run_cli_entry(
 ) -> None:
     """Run the agent chat session using the agent SDK.
 
-
     Raises:
         AgentSetupError: If agent setup fails
         KeyboardInterrupt: If user interrupts the session
         EOFError: If EOF is encountered
     """
 
-    # Normalize queued_inputs to a local copy to prevent mutating the caller's list
-    pending_inputs = list(queued_inputs) if queued_inputs else []
-
     conversation_id = uuid.uuid4()
     if resume_conversation_id:
         try:
             conversation_id = uuid.UUID(resume_conversation_id)
         except ValueError:
-            print_formatted_text(
-                HTML(
-                    f"<yellow>Warning: '{resume_conversation_id}' is not a valid "
-                    f"UUID.</yellow>"
-                )
+            warning = (
+                "<yellow>Warning: '"
+                f"{resume_conversation_id}"
+                "' is not a valid UUID.</yellow>"
             )
+            print_formatted_text(HTML(warning))
             return
 
     try:
@@ -107,10 +103,13 @@ def run_cli_entry(
     conversation = None
     session = get_session_prompter()
 
+    # Initialize pending inputs from queued_inputs
+    pending_inputs = list(queued_inputs) if queued_inputs else []
+
     # Main chat loop
     while True:
         try:
-            # Get user input
+            # Get user input from pending inputs or prompt
             if pending_inputs:
                 user_input = pending_inputs.pop(0)
             else:
@@ -175,22 +174,24 @@ def run_cli_entry(
                 continue
 
             elif command == "/status":
-                if conversation is not None:
+                if conversation:
                     display_status(conversation, session_start_time=session_start_time)
                 else:
                     print_formatted_text(
-                        HTML("<yellow>No active conversation</yellow>")
+                        HTML("<yellow>No active conversation running...</yellow>")
                     )
                 continue
 
             elif command == "/confirm":
-                if runner is not None:
-                    runner.toggle_confirmation_mode()
-                    new_status = (
-                        "enabled" if runner.is_confirmation_mode_active else "disabled"
+                if not runner:
+                    print_formatted_text(
+                        HTML("<yellow>No active conversation running...</yellow>")
                     )
-                else:
-                    new_status = "disabled (no active conversation)"
+                    continue
+                runner.toggle_confirmation_mode()
+                new_status = (
+                    "enabled" if runner.is_confirmation_mode_active else "disabled"
+                )
                 print_formatted_text(
                     HTML(f"<yellow>Confirmation mode {new_status}</yellow>")
                 )

openhands_cli/argparsers/main_parser.py

@@ -15,17 +15,17 @@ def create_main_parser() -> argparse.ArgumentParser:
         description="OpenHands CLI - Terminal User Interface for OpenHands AI Agent",
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog="""
-            By default, OpenHands runs in CLI mode (terminal interface).
-            Use 'serve' subcommand to launch the GUI server instead.
+By default, OpenHands runs in CLI mode (terminal interface).
+Use 'serve' subcommand to launch the GUI server instead.
 
-            Examples:
-                openhands                           # Start CLI mode
-                openhands --resume conversation-id  # Resume a conversation in CLI mode
-                openhands serve                     # Launch GUI server
-                openhands serve --gpu               # Launch GUI server with GPU support
-                openhands acp                       # Start as Agent-Client Protocol
-                                                      server for clients like Zed IDE
-        """,
+Examples:
+  openhands                           # Start CLI mode
+  openhands --resume conversation-id  # Resume a conversation in CLI mode
+  openhands serve                     # Launch GUI server
+  openhands serve --gpu               # Launch GUI server with GPU support
+  openhands acp                       # Start as Agent-Client Protocol
+                                              server for clients like Zed IDE
+""",
     )
 
     # Version argument
@@ -54,6 +54,15 @@ def create_main_parser() -> argparse.ArgumentParser:
     # CLI arguments at top level (default mode)
     parser.add_argument("--resume", type=str, help="Conversation ID to resume")
 
+    # User skills toggle: default on, disable with --no-user-skills
+    parser.add_argument(
+        "--no-user-skills",
+        dest="user_skills",
+        action="store_false",
+        help="Disable loading user skills from ~/.openhands",
+    )
+    parser.set_defaults(user_skills=True)
+
     # Subcommands
     subparsers = parser.add_subparsers(dest="command", help="Additional commands")
 

openhands_cli/setup.py

@@ -5,15 +5,20 @@
 
 from openhands.sdk import Agent, BaseConversation, Conversation, Workspace
 from openhands.sdk.context import AgentContext, Skill
-from openhands.sdk.security.confirmation_policy import (
-    AlwaysConfirm,
+from openhands.sdk.conversation import (
+    visualizer,  # noqa: F401 (ensures tools registered)
 )
+from openhands.sdk.security.confirmation_policy import AlwaysConfirm
 from openhands.sdk.security.llm_analyzer import LLMSecurityAnalyzer
-
-# Register tools on import
-from openhands.tools.file_editor import FileEditorTool  # noqa: F401
-from openhands.tools.task_tracker import TaskTrackerTool  # noqa: F401
-from openhands.tools.terminal import TerminalTool  # noqa: F401
+from openhands.tools.file_editor import (
+    FileEditorTool,  # type: ignore[attr-defined]  # noqa: F401
+)
+from openhands.tools.task_tracker import (
+    TaskTrackerTool,  # type: ignore[attr-defined]  # noqa: F401
+)
+from openhands.tools.terminal import (
+    TerminalTool,  # type: ignore[attr-defined]  # noqa: F401
+)
 from openhands_cli.locations import CONVERSATIONS_DIR, WORK_DIR
 from openhands_cli.tui.settings.settings_screen import SettingsScreen
 from openhands_cli.tui.settings.store import AgentStore
@@ -81,29 +86,32 @@ def load_agent_specs(
 
 
 def verify_agent_exists_or_setup_agent() -> Agent:
-    """Verify agent specs exists by attempting to load it."""
+    """Verify agent specs exists by attempting to load it.
+
+    If missing, run the settings flow and try once more.
+    """
     settings_screen = SettingsScreen()
     try:
         agent = load_agent_specs()
         return agent
     except MissingAgentSpec:
-        # For first-time users, show the full settings flow with choice
-        # between basic/advanced
+        # For first-time users, show the full settings flow with
+        # choice between basic/advanced
         settings_screen.configure_settings(first_time=True)
 
     # Try once again after settings setup attempt
     return load_agent_specs()
 
 
 def setup_conversation(
-    conversation_id: UUID, include_security_analyzer: bool = True
+    conversation_id: UUID,
+    include_security_analyzer: bool = True,
 ) -> BaseConversation:
-    """
-    Setup the conversation with agent.
+    """Setup the conversation with agent.
 
     Args:
-        conversation_id: conversation ID to use. If not provided, a random UUID
-            will be generated.
+        conversation_id: conversation ID to use.
+            If not provided, a random UUID will be generated.
 
     Raises:
         MissingAgentSpec: If agent specification is not found or invalid.

openhands_cli/simple_main.py

@@ -1,8 +1,5 @@
 #!/usr/bin/env python3
-"""
-Simple main entry point for OpenHands CLI.
-This is a simplified version that demonstrates the TUI functionality.
-"""
+"""Simple main entry point for OpenHands CLI."""
 
 import logging
 import os

openhands_cli/tui/settings/store.py

@@ -59,21 +59,28 @@ def load_project_skills(self) -> list:
 
         return all_skills
 
-    def load(self, session_id: str | None = None) -> Agent | None:
+    def load(
+        self,
+        session_id: str | None = None,
+        load_user_skills: bool = True,
+        load_project_skills: bool = True,
+    ) -> Agent | None:
         try:
             str_spec = self.file_store.read(AGENT_SETTINGS_PATH)
             agent = Agent.model_validate_json(str_spec)
 
             # Update tools with most recent working directory
             updated_tools = get_default_tools(enable_browser=False)
 
-            # Load skills from user directories and project-specific directories
-            skills = self.load_project_skills()
+            # Load skills from project-specific directories if enabled
+            skills = []
+            if load_project_skills:
+                skills = self.load_project_skills()
 
             agent_context = AgentContext(
                 skills=skills,
                 system_message_suffix=f"You current working directory is: {WORK_DIR}",
-                load_user_skills=True,
+                load_user_skills=load_user_skills,
             )
 
             mcp_config: dict = self.load_mcp_configuration()

tests/test_cli_signature.py

@@ -0,0 +1,22 @@
+from openhands_cli.argparsers.main_parser import create_main_parser
+
+
+def test_cli_signature_parses_without_args():
+    parser = create_main_parser()
+    args = parser.parse_args([])
+    # Defaults
+    assert getattr(args, "command", None) is None
+    assert getattr(args, "resume", None) is None
+    # user_skills default is True
+    assert args.user_skills is True
+
+
+def test_cli_signature_help_includes_user_skills_flags(capsys):
+    parser = create_main_parser()
+    try:
+        parser.parse_args(["--help"])  # argparse exits SystemExit
+    except SystemExit:
+        pass
+    out = capsys.readouterr().out
+    # Verify flags appear in help text
+    assert "--no-user-skills" in out

tests/test_cli_user_skills_flags.py

@@ -0,0 +1,13 @@
+from openhands_cli.argparsers.main_parser import create_main_parser
+
+
+def test_user_skills_default_true():
+    parser = create_main_parser()
+    args = parser.parse_args([])
+    assert args.user_skills is True
+
+
+def test_user_skills_disable_with_flag():
+    parser = create_main_parser()
+    args = parser.parse_args(["--no-user-skills"])
+    assert args.user_skills is False

tests/test_main.py

@@ -91,10 +91,9 @@ def test_main_handles_eof_error(self, mock_run_agent_chat: MagicMock) -> None:
     def test_main_handles_general_exception(
         self, mock_run_agent_chat: MagicMock
     ) -> None:
-        """Test that main() handles general exceptions."""
+        """Test that main() propagates unexpected exceptions from run_cli_entry."""
         mock_run_agent_chat.side_effect = Exception("Unexpected error")
 
-        # Should raise Exception (re-raised after handling)
         with pytest.raises(Exception) as exc_info:
             simple_main.main()
 
@@ -279,29 +278,3 @@ def test_help_and_invalid(monkeypatch, argv, expected_exit_code):
     with pytest.raises(SystemExit) as exc:
         main()
     assert exc.value.code == expected_exit_code
-
-
-@pytest.mark.parametrize(
-    "argv",
-    [
-        (["openhands", "--version"]),
-        (["openhands", "-v"]),
-    ],
-)
-def test_version_flag(monkeypatch, capsys, argv):
-    """Test that --version and -v flags print version and exit."""
-    monkeypatch.setattr(sys, "argv", argv, raising=False)
-
-    with pytest.raises(SystemExit) as exc:
-        main()
-
-    # Version flag should exit with code 0
-    assert exc.value.code == 0
-
-    # Check that version string is in the output
-    captured = capsys.readouterr()
-    assert "OpenHands CLI" in captured.out
-    # Should contain a version number (matches format like 1.2.1 or 0.0.0)
-    import re
-
-    assert re.search(r"\d+\.\d+\.\d+", captured.out)