kolega-code 0.1.0__py3-none-any.whl

kolega_code/agent/tests/services/test_terminal_state_serializer.py

@@ -0,0 +1,262 @@
+"""Unit tests for terminal state serialization."""
+
+import pytest
+from datetime import datetime
+from unittest.mock import Mock, MagicMock
+from kolega_code.sandbox.serializer import TerminalStateSerializer
+from kolega_code.models.sandbox_terminal_state import SandboxTerminalState, TerminalInfo, TerminalOutput
+
+
+class TestTerminalStateSerializer:
+    """Test terminal state serialization and deserialization."""
+
+    def test_serialize_empty_terminal_manager(self):
+        """Test serializing an empty terminal manager."""
+        terminal_manager = Mock()
+        terminal_manager.terminals = {}
+        terminal_manager.outputs = {}
+
+        state = TerminalStateSerializer.serialize_to_model(terminal_manager, "workspace-123", "sandbox-456")
+
+        assert state.workspace_id == "workspace-123"
+        assert state.sandbox_id == "sandbox-456"
+        assert len(state.terminals) == 0
+        assert len(state.outputs) == 0
+        assert state.total_output_size == 0
+
+    def test_serialize_with_terminals(self):
+        """Test serializing terminal manager with multiple terminals."""
+        terminal_manager = Mock()
+        terminal_manager.terminals = {
+            "term1": {
+                "created_at": datetime.now(),
+                "cwd": "/home/user/workspace",
+                "env": {"PATH": "/usr/bin"},
+                "last_command": "ls -la",
+                "last_command_purpose": "List files",
+            },
+            "term2": {
+                "created_at": datetime.now(),
+                "cwd": "/tmp",
+                "env": {},
+                "last_command": "pwd",
+                "last_command_purpose": "Check directory",
+            },
+        }
+        terminal_manager.outputs = {
+            "term1": [
+                {"type": "command", "data": "ls -la", "timestamp": datetime.now(), "purpose": "List files"},
+                {
+                    "type": "stdout",
+                    "data": "total 24\ndrwxr-xr-x 2 user user 4096 Jan 1 12:00 .\n",
+                    "timestamp": datetime.now(),
+                },
+            ],
+            "term2": [
+                {"type": "command", "data": "pwd", "timestamp": datetime.now(), "purpose": "Check directory"},
+                {"type": "stdout", "data": "/tmp\n", "timestamp": datetime.now()},
+            ],
+        }
+        terminal_manager._default_terminal_id = "term1"
+
+        state = TerminalStateSerializer.serialize_to_model(terminal_manager, "workspace-123", "sandbox-456")
+
+        assert len(state.terminals) == 2
+        assert "term1" in state.terminals
+        assert "term2" in state.terminals
+        assert state.terminals["term1"].last_command == "ls -la"
+        assert state.terminals["term2"].cwd == "/tmp"
+        assert state.default_terminal_id == "term1"
+
+        # Check outputs
+        assert len(state.outputs["term1"]) == 2
+        assert len(state.outputs["term2"]) == 2
+        assert state.outputs["term1"][0].type == "command"
+        assert state.outputs["term1"][1].type == "stdout"
+        assert state.total_output_size > 0
+
+    def test_serialize_with_size_limits(self):
+        """Test that serialization respects size limits."""
+        terminal_manager = Mock()
+        terminal_manager.terminals = {
+            "term1": {
+                "created_at": datetime.now(),
+                "cwd": "/home/user",
+                "env": {},
+                "last_command": "cat large_file.txt",
+                "last_command_purpose": "View file",
+            }
+        }
+
+        # Create large output that exceeds limit
+        large_output = "x" * 300000  # 300KB, exceeds 256KB limit
+        terminal_manager.outputs = {
+            "term1": [
+                {"type": "command", "data": "cat large_file.txt", "timestamp": datetime.now(), "purpose": "View file"},
+                {"type": "stdout", "data": large_output, "timestamp": datetime.now()},
+            ]
+        }
+
+        state = TerminalStateSerializer.serialize_to_model(terminal_manager, "workspace-123", "sandbox-456")
+
+        # Should have truncation notice
+        assert any(output.type == "truncation" for output in state.outputs["term1"])
+        # Total size should be under limit
+        assert state.total_output_size <= state.MAX_OUTPUT_SIZE
+
+    def test_restore_from_model(self):
+        """Test restoring terminal manager from model."""
+        # Create a state model
+        state = SandboxTerminalState(
+            workspace_id="workspace-123",
+            sandbox_id="sandbox-456",
+            terminals={
+                "term1": TerminalInfo(
+                    terminal_id="term1",
+                    created_at=datetime.now(),
+                    cwd="/home/user/workspace",
+                    env={"FOO": "bar"},
+                    last_command="echo hello",
+                    last_command_purpose="Test echo",
+                )
+            },
+            outputs={
+                "term1": [
+                    TerminalOutput(type="command", data="echo hello", timestamp=datetime.now(), purpose="Test echo"),
+                    TerminalOutput(type="stdout", data="hello\n", timestamp=datetime.now()),
+                ]
+            },
+            default_terminal_id="term1",
+        )
+
+        # Create mock terminal manager
+        terminal_manager = Mock()
+        terminal_manager.terminals = {}
+        terminal_manager.outputs = {}
+        terminal_manager._default_terminal_id = None
+
+        # Restore
+        TerminalStateSerializer.restore_from_model(terminal_manager, state)
+
+        # Verify restoration
+        assert len(terminal_manager.terminals) == 1
+        assert "term1" in terminal_manager.terminals
+        assert terminal_manager.terminals["term1"]["cwd"] == "/home/user/workspace"
+        assert terminal_manager.terminals["term1"]["env"]["FOO"] == "bar"
+        assert terminal_manager.terminals["term1"]["last_command"] == "echo hello"
+        assert terminal_manager.terminals["term1"]["process"] is None  # Can't restore process
+
+        # Check outputs
+        assert len(terminal_manager.outputs["term1"]) == 2
+        assert terminal_manager.outputs["term1"][0]["type"] == "command"
+        assert terminal_manager.outputs["term1"][1]["data"] == "hello\n"
+
+        # Check default terminal
+        assert terminal_manager._default_terminal_id == "term1"
+
+    def test_to_frontend_format(self):
+        """Test converting state to frontend format."""
+        state = SandboxTerminalState(
+            workspace_id="workspace-123",
+            sandbox_id="sandbox-456",
+            terminals={
+                "term1": TerminalInfo(
+                    terminal_id="term1",
+                    created_at=datetime.now(),
+                    cwd="/home/user",
+                    env={},
+                    last_command="ls",
+                    last_command_purpose="",
+                ),
+                "term2": TerminalInfo(
+                    terminal_id="term2",
+                    created_at=datetime.now(),
+                    cwd="/tmp",
+                    env={},
+                    last_command="pwd",
+                    last_command_purpose="",
+                ),
+            },
+            outputs={
+                "term1": [
+                    TerminalOutput(type="command", data="ls", timestamp=datetime.now()),
+                    TerminalOutput(type="stdout", data="file1.txt\nfile2.txt\n", timestamp=datetime.now()),
+                    TerminalOutput(
+                        type="exit", data="Process exited with code 0", timestamp=datetime.now(), exit_code=0
+                    ),
+                ],
+                "term2": [
+                    TerminalOutput(type="command", data="pwd", timestamp=datetime.now()),
+                    TerminalOutput(type="stdout", data="/tmp", timestamp=datetime.now()),
+                ],
+            },
+        )
+
+        frontend_data = TerminalStateSerializer.to_frontend_format(state)
+
+        assert "terminals" in frontend_data
+        assert len(frontend_data["terminals"]) == 2
+
+        # Find terminals by ID
+        term1_data = next(t for t in frontend_data["terminals"] if t["id"] == "term1")
+        term2_data = next(t for t in frontend_data["terminals"] if t["id"] == "term2")
+
+        # Check content formatting
+        assert "$ ls" in term1_data["content"]
+        assert "file1.txt\nfile2.txt" in term1_data["content"]
+        assert "Process exited with code 0" in term1_data["content"]
+
+        assert "$ pwd" in term2_data["content"]
+        assert "/tmp" in term2_data["content"]
+
+    def test_get_recent_outputs(self):
+        """Test getting recent outputs with line limit."""
+        outputs = []
+
+        # Add many outputs
+        for i in range(20):
+            outputs.append({"type": "command", "data": f"echo line{i}", "timestamp": datetime.now()})
+            outputs.append({"type": "stdout", "data": f"line{i}\n" * 10, "timestamp": datetime.now()})  # 10 lines each
+
+        # Get recent outputs with limit
+        recent = TerminalStateSerializer.get_recent_outputs(outputs, max_lines=50)
+
+        # Should have truncated older outputs
+        assert len(recent) < len(outputs)
+
+        # Count total lines
+        total_lines = 0
+        for output in recent:
+            if output["type"] == "command":
+                total_lines += 1
+            elif output["type"] in ["stdout", "stderr"]:
+                total_lines += output["data"].count("\n") + 1
+
+        # Should be close to limit (may be slightly over due to partial output)
+        assert total_lines <= 60  # Some buffer for partial outputs
+
+    def test_serialize_handles_missing_terminal_manager_attrs(self):
+        """Test serialization handles terminal managers without expected attributes."""
+        # Terminal manager without 'terminals' attribute (e.g., local terminal manager)
+        terminal_manager = Mock(spec=[])  # No attributes
+
+        state = TerminalStateSerializer.serialize_to_model(terminal_manager, "workspace-123", "sandbox-456")
+
+        # Should return empty state
+        assert state.workspace_id == "workspace-123"
+        assert state.sandbox_id == "sandbox-456"
+        assert len(state.terminals) == 0
+        assert len(state.outputs) == 0
+
+    def test_restore_handles_none_state(self):
+        """Test restore handles None state gracefully."""
+        terminal_manager = Mock()
+        terminal_manager.terminals = {"existing": {}}
+        terminal_manager.outputs = {"existing": []}
+
+        # Should not raise exception
+        TerminalStateSerializer.restore_from_model(terminal_manager, None)
+
+        # Should not modify terminal manager
+        assert "existing" in terminal_manager.terminals
+        assert "existing" in terminal_manager.outputs

kolega_code/agent/tests/test_agent_tools_inventory.py

@@ -0,0 +1,267 @@
+"""Tool inventory checks for shared agent classes."""
+
+import uuid
+from pathlib import Path
+from unittest.mock import AsyncMock, Mock
+
+import pytest
+
+from kolega_code.agent.browseragent import BrowserAgent
+from kolega_code.agent.coder import CoderAgent
+from kolega_code.config import AgentConfig
+from kolega_code.events import AgentConnectionManager
+from kolega_code.agent.generalagent import GeneralAgent
+from kolega_code.agent.investigationagent import InvestigationAgent
+from kolega_code.agent.planningagent import PlanningAgent
+from kolega_code.agent.prompt_provider import AgentMode, PromptProvider
+
+
+@pytest.fixture
+def mock_connection_manager():
+    """Create a mock connection manager."""
+    manager = Mock(spec=AgentConnectionManager)
+    manager.workspace_id = "test_workspace"
+    manager.send_message = AsyncMock()
+    return manager
+
+
+@pytest.fixture
+def agent_config():
+    """Create a mock agent configuration."""
+    config = Mock(spec=AgentConfig)
+    config.long_context_config = Mock()
+    config.long_context_config.provider = "anthropic"
+    config.long_context_config.model = "claude-sonnet-4-5-20250929"
+    config.openai_api_key = "test_key"
+    config.anthropic_api_key = "test_key"
+    config.browser_use_headless = True
+    return config
+
+
+@pytest.fixture
+def project_path(tmp_path):
+    """Create a temporary project path."""
+    return str(tmp_path)
+
+
+def hosted_prompt_provider(project_path):
+    template_dir = Path(project_path) / "prompt_templates"
+    agents_dir = template_dir / "agents"
+    agents_dir.mkdir(parents=True, exist_ok=True)
+    (agents_dir / "coder_code_mode.j2").write_text("Private hosted test prompt.", encoding="utf-8")
+    return PromptProvider(template_dirs=[template_dir])
+
+
+def test_browser_agent_tools(project_path, mock_connection_manager, agent_config):
+    """BrowserAgent exposes only browser tools."""
+    agent = BrowserAgent(
+        project_path=project_path,
+        workspace_id="test_workspace",
+        thread_id=str(uuid.uuid4()),
+        connection_manager=mock_connection_manager,
+        config=agent_config,
+    )
+
+    tools = agent.tool_collection.get_tool_list()
+    tool_names = [tool.name for tool in tools]
+
+    expected_tools = [
+        "close_browser",
+        "get_browser_console_logs",
+        "get_browser_interactive_elements",
+        "interact_with_browser",
+        "launch_browser",
+        "list_browsers",
+        "set_browser_select_value",
+        "take_browser_screenshot",
+    ]
+
+    assert len(tools) == len(expected_tools)
+    assert set(tool_names) == set(expected_tools)
+
+
+def test_investigation_agent_tools(project_path, mock_connection_manager, agent_config):
+    """InvestigationAgent exposes read-only investigation tools."""
+    agent = InvestigationAgent(
+        project_path=project_path,
+        workspace_id="test_workspace",
+        thread_id=str(uuid.uuid4()),
+        connection_manager=mock_connection_manager,
+        config=agent_config,
+    )
+
+    tools = agent.tool_collection.get_tool_list()
+    tool_names = [tool.name for tool in tools]
+
+    expected_tools = [
+        "find_files_by_pattern",
+        "list_directory",
+        "read_entire_file",
+        "read_file_section",
+        "search_codebase",
+        "sleep",
+        "think_hard",
+        "web_fetch",
+    ]
+
+    assert len(tools) == len(expected_tools)
+    assert set(tool_names) == set(expected_tools)
+
+
+def test_cli_coder_agent_does_not_expose_manifest_build_tools(project_path, mock_connection_manager, agent_config):
+    """CLI CoderAgent does not expose platform-only manifest build tools."""
+    agent = CoderAgent(
+        project_path=project_path,
+        workspace_id="test_workspace",
+        thread_id=str(uuid.uuid4()),
+        connection_manager=mock_connection_manager,
+        config=agent_config,
+        agent_mode=AgentMode.CLI,
+    )
+
+    tool_names = {tool.name for tool in agent.tool_collection.get_tool_list()}
+
+    assert "build_backend" not in tool_names
+    assert "build_frontend" not in tool_names
+
+
+def test_non_cli_coder_agent_keeps_manifest_build_tools(project_path, mock_connection_manager, agent_config):
+    """Non-CLI CoderAgent keeps manifest build tools for platform use."""
+    agent = CoderAgent(
+        project_path=project_path,
+        workspace_id="test_workspace",
+        thread_id=str(uuid.uuid4()),
+        connection_manager=mock_connection_manager,
+        config=agent_config,
+        agent_mode=AgentMode.CODE,
+        prompt_provider=hosted_prompt_provider(project_path),
+    )
+
+    tool_names = {tool.name for tool in agent.tool_collection.get_tool_list()}
+
+    assert "build_backend" in tool_names
+    assert "build_frontend" in tool_names
+
+
+def test_coder_agent_exposes_dispatch_general_agent(project_path, mock_connection_manager, agent_config):
+    """CoderAgent can dispatch general sub-agents but still not coding agents."""
+    agent = CoderAgent(
+        project_path=project_path,
+        workspace_id="test_workspace",
+        thread_id=str(uuid.uuid4()),
+        connection_manager=mock_connection_manager,
+        config=agent_config,
+        agent_mode=AgentMode.CLI,
+    )
+
+    tool_names = {tool.name for tool in agent.tool_collection.get_tool_list()}
+
+    assert "dispatch_general_agent" in tool_names
+    assert "dispatch_investigation_agent" in tool_names
+    assert "dispatch_coding_agent" not in tool_names
+
+
+def test_sub_agent_coder_cannot_dispatch_general_agent(project_path, mock_connection_manager, agent_config):
+    """A dispatched CoderAgent must not fan out into further sub-agents."""
+    agent = CoderAgent(
+        project_path=project_path,
+        workspace_id="test_workspace",
+        thread_id=str(uuid.uuid4()),
+        connection_manager=mock_connection_manager,
+        config=agent_config,
+        agent_mode=AgentMode.CLI,
+        sub_agent=True,
+    )
+
+    tool_names = {tool.name for tool in agent.tool_collection.get_tool_list()}
+
+    assert "dispatch_general_agent" not in tool_names
+
+
+def test_general_agent_tool_inventory(project_path, mock_connection_manager, agent_config):
+    """GeneralAgent has the full toolset but cannot dispatch sub-agents."""
+    agent = GeneralAgent(
+        project_path=project_path,
+        workspace_id="test_workspace",
+        thread_id=str(uuid.uuid4()),
+        connection_manager=mock_connection_manager,
+        config=agent_config,
+    )
+
+    tool_names = {tool.name for tool in agent.tool_collection.get_tool_list()}
+
+    # Full read/write/terminal access
+    assert "read_entire_file" in tool_names
+    assert "search_codebase" in tool_names
+    assert "create_file" in tool_names
+    assert "replace_entire_file" in tool_names
+    assert "run_command_tracked" in tool_names
+    # Recursion guard: no dispatch tools at all
+    assert not any(name.startswith("dispatch_") for name in tool_names)
+
+
+def test_cli_general_agent_excludes_manifest_build_tools(project_path, mock_connection_manager, agent_config):
+    """GeneralAgent inherits the CLI-mode exclusion of platform build tools."""
+    agent = GeneralAgent(
+        project_path=project_path,
+        workspace_id="test_workspace",
+        thread_id=str(uuid.uuid4()),
+        connection_manager=mock_connection_manager,
+        config=agent_config,
+        agent_mode=AgentMode.CLI,
+    )
+
+    tool_names = {tool.name for tool in agent.tool_collection.get_tool_list()}
+
+    assert "build_backend" not in tool_names
+    assert "build_frontend" not in tool_names
+
+
+def test_planning_agent_exposes_read_only_and_planning_tools(project_path, mock_connection_manager, agent_config):
+    """PlanningAgent cannot edit files and can capture a final plan."""
+    agent = PlanningAgent(
+        project_path=project_path,
+        workspace_id="test_workspace",
+        thread_id=str(uuid.uuid4()),
+        connection_manager=mock_connection_manager,
+        config=agent_config,
+        agent_mode=AgentMode.CLI,
+    )
+
+    tool_names = {tool.name for tool in agent.tool_collection.get_tool_list()}
+    expected_planning_tools = {"write_plan"}
+
+    assert expected_planning_tools.issubset(tool_names)
+    assert "get_task_list" not in tool_names
+    assert "update_task_list" not in tool_names
+    assert "create_file" not in tool_names
+    assert "replace_entire_file" not in tool_names
+    assert "apply_patch" not in tool_names
+    assert "run_command_tracked" not in tool_names
+    assert tool_names - expected_planning_tools <= set(agent.tool_collection.read_only_tools)
+
+
+def test_shared_tool_names_are_well_formed(project_path, mock_connection_manager, agent_config):
+    """Shared agent tool definitions have valid names and descriptions."""
+    agents = [
+        BrowserAgent(
+            project_path=project_path,
+            workspace_id="test_workspace",
+            thread_id=str(uuid.uuid4()),
+            connection_manager=mock_connection_manager,
+            config=agent_config,
+        ),
+        InvestigationAgent(
+            project_path=project_path,
+            workspace_id="test_workspace",
+            thread_id=str(uuid.uuid4()),
+            connection_manager=mock_connection_manager,
+            config=agent_config,
+        ),
+    ]
+
+    for agent in agents:
+        for tool in agent.tool_collection.get_tool_list():
+            assert tool.name.replace("_", "").isalnum()
+            assert tool.name.islower() or tool.name.replace("_", "").isalnum()
+            assert tool.description