Replace --triage flag with --agent option for query command

- Add --agent/-a option with choices: auto, triage, chat, knowledge
- Default to 'auto' which uses the router to select the agent
- Update help text to document all agent types
- Add comprehensive tests for each agent selection mode
- Regenerate CLI reference docs

Author: abrookins

docs/reference/cli.md

@@ -73,10 +73,11 @@ Generated from the Click command tree.
     to continue an existing conversation, or omit it to start a new one.
 
     
-    The agent is automatically selected based on the query:
-      - Knowledge agent: General Redis questions (no instance)
-      - Chat agent: Quick questions with a Redis instance
-      - Triage agent: Full health checks or --triage flag
+    The agent is automatically selected based on the query, or use --agent:
+      - knowledge: General Redis questions (no instance needed)
+      - chat: Quick questions with a Redis instance
+      - triage: Full health checks and diagnostics
+      - auto: Let the router decide (default)
 - worker — Start the background worker.
 - mcp — MCP server commands - expose agent capabilities via Model Context Protocol.
 - mcp list-tools — List available MCP tools.

redis_sre_agent/cli/query.py

@@ -24,18 +24,25 @@
 @click.argument("query")
 @click.option("--redis-instance-id", "-r", help="Redis instance ID to investigate")
 @click.option("--thread-id", "-t", help="Thread ID to continue an existing conversation")
-@click.option("--triage", is_flag=True, help="Force full triage agent (bypasses routing)")
-def query(query: str, redis_instance_id: Optional[str], thread_id: Optional[str], triage: bool):
+@click.option(
+    "--agent",
+    "-a",
+    type=click.Choice(["auto", "triage", "chat", "knowledge"], case_sensitive=False),
+    default="auto",
+    help="Agent to use (default: auto-select based on query)",
+)
+def query(query: str, redis_instance_id: Optional[str], thread_id: Optional[str], agent: str):
     """Execute an agent query.
 
     Supports conversation threads for multi-turn interactions. Use --thread-id
     to continue an existing conversation, or omit it to start a new one.
 
     \b
-    The agent is automatically selected based on the query:
-      - Knowledge agent: General Redis questions (no instance)
-      - Chat agent: Quick questions with a Redis instance
-      - Triage agent: Full health checks or --triage flag
+    The agent is automatically selected based on the query, or use --agent:
+      - knowledge: General Redis questions (no instance needed)
+      - chat: Quick questions with a Redis instance
+      - triage: Full health checks and diagnostics
+      - auto: Let the router decide (default)
     """
 
     async def _query():
@@ -100,10 +107,18 @@ async def _query():
         # Build context for routing
         routing_context = {"instance_id": instance.id} if instance else None
 
+        # Map CLI agent choice to AgentType
+        agent_choice_map = {
+            "triage": AgentType.REDIS_TRIAGE,
+            "chat": AgentType.REDIS_CHAT,
+            "knowledge": AgentType.KNOWLEDGE_ONLY,
+        }
+
         # Determine which agent to use
-        if triage:
-            agent_type = AgentType.REDIS_TRIAGE
-            console.print("[dim]🔧 Agent: Triage (forced)[/dim]")
+        if agent != "auto":
+            agent_type = agent_choice_map[agent.lower()]
+            agent_label = agent.capitalize()
+            console.print(f"[dim]🔧 Agent: {agent_label} (selected)[/dim]")
         else:
             agent_type = await route_to_appropriate_agent(
                 query=query,
@@ -116,19 +131,19 @@ async def _query():
             }.get(agent_type, agent_type.value)
             console.print(f"[dim]🔧 Agent: {agent_label}[/dim]")
 
-        # Get the appropriate agent
+        # Get the appropriate agent instance
         if agent_type == AgentType.REDIS_TRIAGE:
-            agent = get_sre_agent()
+            selected_agent = get_sre_agent()
         elif agent_type == AgentType.REDIS_CHAT:
-            agent = get_chat_agent(redis_instance=instance)
+            selected_agent = get_chat_agent(redis_instance=instance)
         else:
-            agent = get_knowledge_agent()
+            selected_agent = get_knowledge_agent()
 
         try:
             context = {"instance_id": instance.id} if instance else None
 
             # Run the agent
-            response = await agent.process_query(
+            response = await selected_agent.process_query(
                 query,
                 session_id="cli",
                 user_id="cli_user",

tests/unit/cli/test_cli_query.py

@@ -7,13 +7,19 @@
 from redis_sre_agent.cli.query import query
 
 
-def test_query_cli_help_shows_instance_option():
+def test_query_cli_help_shows_options():
     runner = CliRunner()
     result = runner.invoke(query, ["--help"])
 
     assert result.exit_code == 0
     assert "--redis-instance-id" in result.output
     assert "-r" in result.output
+    assert "--agent" in result.output
+    assert "-a" in result.output
+    assert "auto" in result.output
+    assert "triage" in result.output
+    assert "chat" in result.output
+    assert "knowledge" in result.output
 
 
 def test_query_without_instance_uses_knowledge_agent():
@@ -144,3 +150,161 @@ def test_query_with_unknown_instance_exits_with_error_and_skips_agents():
     mock_get_knowledge.assert_not_called()
     mock_get_sre.assert_not_called()
     mock_agent.process_query.assert_not_awaited()
+
+
+def test_query_with_agent_triage_forces_triage_agent():
+    """Test that --agent triage forces use of the triage agent."""
+    runner = CliRunner()
+
+    mock_agent = MagicMock()
+    mock_agent.process_query = AsyncMock(return_value="triage result")
+
+    with (
+        patch("redis_sre_agent.cli.query.get_sre_agent", return_value=mock_agent) as mock_get_sre,
+        patch("redis_sre_agent.cli.query.get_knowledge_agent") as mock_get_knowledge,
+        patch("redis_sre_agent.cli.query.get_chat_agent") as mock_get_chat,
+        patch("redis_sre_agent.cli.query.route_to_appropriate_agent") as mock_router,
+    ):
+        result = runner.invoke(query, ["--agent", "triage", "Check my Redis health"])
+
+    assert result.exit_code == 0, result.output
+    assert "Triage (selected)" in result.output
+
+    # Triage agent should be used
+    mock_get_sre.assert_called_once()
+    mock_get_knowledge.assert_not_called()
+    mock_get_chat.assert_not_called()
+
+    # Router should NOT be called when agent is explicitly specified
+    mock_router.assert_not_called()
+
+    mock_agent.process_query.assert_awaited_once()
+
+
+def test_query_with_agent_knowledge_forces_knowledge_agent():
+    """Test that --agent knowledge forces use of the knowledge agent."""
+    runner = CliRunner()
+
+    mock_agent = MagicMock()
+    mock_agent.process_query = AsyncMock(return_value="knowledge result")
+
+    with (
+        patch(
+            "redis_sre_agent.cli.query.get_knowledge_agent", return_value=mock_agent
+        ) as mock_get_knowledge,
+        patch("redis_sre_agent.cli.query.get_sre_agent") as mock_get_sre,
+        patch("redis_sre_agent.cli.query.get_chat_agent") as mock_get_chat,
+        patch("redis_sre_agent.cli.query.route_to_appropriate_agent") as mock_router,
+    ):
+        result = runner.invoke(query, ["-a", "knowledge", "What is Redis replication?"])
+
+    assert result.exit_code == 0, result.output
+    assert "Knowledge (selected)" in result.output
+
+    # Knowledge agent should be used
+    mock_get_knowledge.assert_called_once()
+    mock_get_sre.assert_not_called()
+    mock_get_chat.assert_not_called()
+
+    # Router should NOT be called
+    mock_router.assert_not_called()
+
+    mock_agent.process_query.assert_awaited_once()
+
+
+def test_query_with_agent_chat_forces_chat_agent():
+    """Test that --agent chat forces use of the chat agent."""
+    runner = CliRunner()
+
+    class DummyInstance:
+        def __init__(self):
+            self.id = "test-instance"
+            self.name = "Test Instance"
+            self.instance_type = "oss_single"
+            self.connection_url = "redis://localhost:6379"
+            self.environment = "development"
+            self.usage = "cache"
+
+    instance = DummyInstance()
+
+    mock_agent = MagicMock()
+    mock_agent.process_query = AsyncMock(return_value="chat result")
+
+    with (
+        patch("redis_sre_agent.cli.query.get_chat_agent", return_value=mock_agent) as mock_get_chat,
+        patch("redis_sre_agent.cli.query.get_sre_agent") as mock_get_sre,
+        patch("redis_sre_agent.cli.query.get_knowledge_agent") as mock_get_knowledge,
+        patch(
+            "redis_sre_agent.cli.query.get_instance_by_id",
+            new=AsyncMock(return_value=instance),
+        ),
+        patch("redis_sre_agent.cli.query.route_to_appropriate_agent") as mock_router,
+    ):
+        result = runner.invoke(query, ["--agent", "chat", "-r", "test-instance", "Quick question"])
+
+    assert result.exit_code == 0, result.output
+    assert "Chat (selected)" in result.output
+
+    # Chat agent should be used
+    mock_get_chat.assert_called_once()
+    mock_get_sre.assert_not_called()
+    mock_get_knowledge.assert_not_called()
+
+    # Router should NOT be called
+    mock_router.assert_not_called()
+
+    mock_agent.process_query.assert_awaited_once()
+
+
+def test_query_with_agent_auto_uses_router():
+    """Test that --agent auto (default) uses the router to select agent."""
+    runner = CliRunner()
+
+    from redis_sre_agent.agent.router import AgentType
+
+    mock_agent = MagicMock()
+    mock_agent.process_query = AsyncMock(return_value="routed result")
+
+    with (
+        patch(
+            "redis_sre_agent.cli.query.get_knowledge_agent", return_value=mock_agent
+        ) as mock_get_knowledge,
+        patch("redis_sre_agent.cli.query.get_sre_agent") as mock_get_sre,
+        patch(
+            "redis_sre_agent.cli.query.route_to_appropriate_agent",
+            new=AsyncMock(return_value=AgentType.KNOWLEDGE_ONLY),
+        ) as mock_router,
+    ):
+        # Default is auto, so router should be called
+        result = runner.invoke(query, ["What is Redis?"])
+
+    assert result.exit_code == 0, result.output
+    # Should show "Knowledge" without "(selected)" since it was auto-routed
+    assert "Agent: Knowledge" in result.output
+    assert "(selected)" not in result.output
+
+    # Router should be called
+    mock_router.assert_awaited_once()
+
+    mock_get_knowledge.assert_called_once()
+    mock_get_sre.assert_not_called()
+
+
+def test_query_agent_option_is_case_insensitive():
+    """Test that --agent option accepts different cases."""
+    runner = CliRunner()
+
+    mock_agent = MagicMock()
+    mock_agent.process_query = AsyncMock(return_value="result")
+
+    with (
+        patch("redis_sre_agent.cli.query.get_knowledge_agent", return_value=mock_agent),
+        patch("redis_sre_agent.cli.query.route_to_appropriate_agent"),
+    ):
+        # Test uppercase
+        result = runner.invoke(query, ["--agent", "KNOWLEDGE", "test query"])
+        assert result.exit_code == 0, result.output
+
+        # Test mixed case
+        result = runner.invoke(query, ["--agent", "Knowledge", "test query"])
+        assert result.exit_code == 0, result.output