kolega-code 0.1.0__py3-none-any.whl

kolega_code/agent/tests/tool_backend/test_list_directory_tool.py

@@ -0,0 +1,292 @@
+"""Unit tests for the ListDirectoryTool with local filesystem."""
+
+import pytest
+import pytest_asyncio
+import tempfile
+import os
+from pathlib import Path
+from unittest.mock import Mock, AsyncMock
+from datetime import datetime
+
+from kolega_code.services.file_system import LocalFileSystem
+from kolega_code.agent.tool_backend.list_directory_tool import ListDirectoryTool
+from kolega_code.agent.baseagent import BaseAgent
+
+
+class TestListDirectoryTool:
+    """Unit tests for list directory tool with local filesystem."""
+
+    @pytest_asyncio.fixture
+    async def test_directory(self):
+        """Create a temporary directory with test files."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create test structure
+            os.makedirs(os.path.join(tmpdir, ".git", "objects"))
+            os.makedirs(os.path.join(tmpdir, "src", "components"))
+            os.makedirs(os.path.join(tmpdir, "docs"))
+            os.makedirs(os.path.join(tmpdir, "tests"))
+
+            # Create files
+            Path(os.path.join(tmpdir, "main.py")).write_text('print("Hello")')
+            Path(os.path.join(tmpdir, "README.md")).write_text("# Project")
+            Path(os.path.join(tmpdir, "package.json")).write_text('{"name": "test"}')
+            Path(os.path.join(tmpdir, "Dockerfile")).write_text("FROM python:3.9")
+            Path(os.path.join(tmpdir, ".gitignore")).write_text("*.pyc\n__pycache__/")
+            Path(os.path.join(tmpdir, "requirements.txt")).write_text("pytest==7.0.0")
+
+            # Create files in subdirectories
+            Path(os.path.join(tmpdir, ".git", "config")).write_text("[core]\n")
+            Path(os.path.join(tmpdir, "src", "app.py")).write_text("def main(): pass")
+            Path(os.path.join(tmpdir, "src", "components", "button.py")).write_text("class Button: pass")
+            Path(os.path.join(tmpdir, "docs", "api.md")).write_text("# API")
+            Path(os.path.join(tmpdir, "tests", "test_main.py")).write_text("def test_main(): pass")
+
+            # Create a larger file
+            with open(os.path.join(tmpdir, "large.dat"), "wb") as f:
+                f.write(b"0" * (1024 * 1024))  # 1MB file
+
+            yield tmpdir
+
+    @pytest.fixture
+    def mock_agent(self):
+        """Create a mock agent for the tool."""
+        agent = Mock(spec=BaseAgent)
+        agent.agent_name = "test-agent"
+        agent.log_info = AsyncMock()
+        agent.log_error = AsyncMock()
+        return agent
+
+    @pytest.mark.asyncio
+    async def test_list_root_excludes_git(self, test_directory, mock_agent):
+        """Test that .git directory is excluded from root listing."""
+        # Create filesystem and tool
+        filesystem = LocalFileSystem(root_path=test_directory)
+        tool = ListDirectoryTool(
+            project_path=test_directory,
+            workspace_id="test",
+            thread_id="test",
+            connection_manager=Mock(),
+            config=Mock(),
+            caller=mock_agent,
+            filesystem=filesystem,
+        )
+
+        # List root directory
+        result = await tool.list_directory("")
+
+        # Verify .git is not in the output
+        assert "| 📁 | .git" not in result
+
+        # Verify other directories are present
+        assert "| 📁 | src" in result
+        assert "| 📁 | docs" in result
+        assert "| 📁 | tests" in result
+
+        # Verify files are present
+        assert "| 📄 | main.py" in result
+        assert "| 📄 | README.md" in result
+        assert "| 📄 | .gitignore" in result
+
+    @pytest.mark.asyncio
+    async def test_file_descriptions(self, test_directory, mock_agent):
+        """Test that file descriptions are correct."""
+        filesystem = LocalFileSystem(root_path=test_directory)
+        tool = ListDirectoryTool(
+            project_path=test_directory,
+            workspace_id="test",
+            thread_id="test",
+            connection_manager=Mock(),
+            config=Mock(),
+            caller=mock_agent,
+            filesystem=filesystem,
+        )
+
+        result = await tool.list_directory("")
+
+        # Check file descriptions
+        assert "Python Source |" in result  # main.py
+        assert "Project Documentation |" in result  # README.md
+        assert "Node.js Package |" in result  # package.json
+        assert "Docker Definition |" in result  # Dockerfile
+        assert "Git Ignore Rules |" in result  # .gitignore
+        assert "Python Dependencies |" in result  # requirements.txt
+        assert "DAT File |" in result  # large.dat
+
+    @pytest.mark.asyncio
+    async def test_file_sizes(self, test_directory, mock_agent):
+        """Test that file sizes are displayed correctly."""
+        filesystem = LocalFileSystem(root_path=test_directory)
+        tool = ListDirectoryTool(
+            project_path=test_directory,
+            workspace_id="test",
+            thread_id="test",
+            connection_manager=Mock(),
+            config=Mock(),
+            caller=mock_agent,
+            filesystem=filesystem,
+        )
+
+        result = await tool.list_directory("")
+
+        # The large.dat file should show as 1.0 MB
+        lines = result.split("\n")
+        large_file_line = [line for line in lines if "large.dat" in line][0]
+        assert "1.0 MB" in large_file_line
+
+        # Small files should show in bytes
+        main_py_line = [line for line in lines if "main.py" in line][0]
+        assert " B |" in main_py_line
+
+    @pytest.mark.asyncio
+    async def test_directory_item_counts(self, test_directory, mock_agent):
+        """Test that directory item counts are correct."""
+        filesystem = LocalFileSystem(root_path=test_directory)
+        tool = ListDirectoryTool(
+            project_path=test_directory,
+            workspace_id="test",
+            thread_id="test",
+            connection_manager=Mock(),
+            config=Mock(),
+            caller=mock_agent,
+            filesystem=filesystem,
+        )
+
+        result = await tool.list_directory("")
+
+        # Check directory item counts
+        lines = result.split("\n")
+        src_line = [line for line in lines if "| 📁 | src" in line][0]
+        assert "2 items" in src_line  # app.py and components/
+
+        docs_line = [line for line in lines if "| 📁 | docs" in line][0]
+        assert "1 items" in docs_line  # api.md
+
+        tests_line = [line for line in lines if "| 📁 | tests" in line][0]
+        assert "1 items" in tests_line  # test_main.py
+
+    @pytest.mark.asyncio
+    async def test_subdirectory_listing(self, test_directory, mock_agent):
+        """Test listing a subdirectory."""
+        filesystem = LocalFileSystem(root_path=test_directory)
+        tool = ListDirectoryTool(
+            project_path=test_directory,
+            workspace_id="test",
+            thread_id="test",
+            connection_manager=Mock(),
+            config=Mock(),
+            caller=mock_agent,
+            filesystem=filesystem,
+        )
+
+        result = await tool.list_directory("src")
+
+        # Verify header and navigation
+        assert "# Directory: src" in result
+        assert "📁 Root Directory" in result
+
+        # Verify contents
+        assert "| 📄 | app.py" in result
+        assert "| 📁 | components" in result
+        assert "Python Source |" in result
+
+    @pytest.mark.asyncio
+    async def test_nested_directory(self, test_directory, mock_agent):
+        """Test listing a nested directory."""
+        filesystem = LocalFileSystem(root_path=test_directory)
+        tool = ListDirectoryTool(
+            project_path=test_directory,
+            workspace_id="test",
+            thread_id="test",
+            connection_manager=Mock(),
+            config=Mock(),
+            caller=mock_agent,
+            filesystem=filesystem,
+        )
+
+        result = await tool.list_directory("src/components")
+
+        # Verify header and navigation
+        assert "# Directory: src/components" in result
+        assert "📁 Parent Directory: src" in result
+
+        # Verify contents
+        assert "| 📄 | button.py" in result
+        assert "Python Source |" in result
+
+    @pytest.mark.asyncio
+    async def test_nonexistent_directory(self, test_directory, mock_agent):
+        """Test error handling for non-existent directory."""
+        filesystem = LocalFileSystem(root_path=test_directory)
+        tool = ListDirectoryTool(
+            project_path=test_directory,
+            workspace_id="test",
+            thread_id="test",
+            connection_manager=Mock(),
+            config=Mock(),
+            caller=mock_agent,
+            filesystem=filesystem,
+        )
+
+        with pytest.raises(FileNotFoundError) as exc_info:
+            await tool.list_directory("nonexistent")
+
+        assert "Directory not found: nonexistent" in str(exc_info.value)
+
+    @pytest.mark.asyncio
+    async def test_list_file_instead_of_directory(self, test_directory, mock_agent):
+        """Test error when trying to list a file."""
+        filesystem = LocalFileSystem(root_path=test_directory)
+        tool = ListDirectoryTool(
+            project_path=test_directory,
+            workspace_id="test",
+            thread_id="test",
+            connection_manager=Mock(),
+            config=Mock(),
+            caller=mock_agent,
+            filesystem=filesystem,
+        )
+
+        with pytest.raises(NotADirectoryError) as exc_info:
+            await tool.list_directory("main.py")
+
+        assert "Not a directory: main.py" in str(exc_info.value)
+
+    @pytest.mark.asyncio
+    async def test_summary_counts(self, test_directory, mock_agent):
+        """Test that summary counts are correct."""
+        filesystem = LocalFileSystem(root_path=test_directory)
+        tool = ListDirectoryTool(
+            project_path=test_directory,
+            workspace_id="test",
+            thread_id="test",
+            connection_manager=Mock(),
+            config=Mock(),
+            caller=mock_agent,
+            filesystem=filesystem,
+        )
+
+        result = await tool.list_directory("")
+
+        # Verify summary - should be 3 directories (not counting .git) and 7 files
+        assert "**Summary:** 3 directories, 7 files" in result
+
+    @pytest.mark.asyncio
+    async def test_dates_shown(self, test_directory, mock_agent):
+        """Test that modification dates are shown."""
+        filesystem = LocalFileSystem(root_path=test_directory)
+        tool = ListDirectoryTool(
+            project_path=test_directory,
+            workspace_id="test",
+            thread_id="test",
+            connection_manager=Mock(),
+            config=Mock(),
+            caller=mock_agent,
+            filesystem=filesystem,
+        )
+
+        result = await tool.list_directory("")
+
+        # Dates should be in YYYY-MM-DD HH:MM format
+        current_year = datetime.now().year
+        assert f"{current_year}-" in result
+        assert "Unknown" not in result  # No unknown dates

kolega_code/agent/tests/tool_backend/test_read_file_tool.py

@@ -0,0 +1,173 @@
+from unittest.mock import AsyncMock, Mock
+
+import pytest
+import uuid
+
+from kolega_code.config import AgentConfig, ModelConfig, ModelProvider, RateLimitConfig
+from kolega_code.agent.tool_backend.read_file_tool import ReadFileTool
+
+
+@pytest.fixture
+def mock_connection_manager():
+    return AsyncMock()
+
+
+@pytest.fixture
+def project_path(tmp_path):
+    return tmp_path
+
+
+@pytest.fixture
+def agent_config():
+    return AgentConfig(
+        anthropic_api_key="test_key",
+        openai_api_key="test-key",
+        long_context_config=ModelConfig(
+            provider=ModelProvider.ANTHROPIC, model="test-model", rate_limits=RateLimitConfig()
+        ),
+        fast_config=ModelConfig(provider=ModelProvider.ANTHROPIC, model="test-model", rate_limits=RateLimitConfig()),
+        thinking_config=ModelConfig(
+            provider=ModelProvider.ANTHROPIC, model="test-model", rate_limits=RateLimitConfig(), thinking_tokens=1024
+        ),
+    )
+
+
+@pytest.fixture
+def mock_base_agent():
+    return Mock()
+
+
+@pytest.fixture
+def read_file_tool(project_path, mock_connection_manager, agent_config, mock_base_agent):
+    return ReadFileTool(
+        project_path, "test_workspace", str(uuid.uuid4()), mock_connection_manager, agent_config, mock_base_agent
+    )
+
+
+@pytest.fixture
+def sample_file(project_path):
+    file_path = project_path / "test.txt"
+    file_path.write_text("Line 1\nLine 2\nLine 3\nLine 4\nLine 5")
+    return file_path
+
+
+@pytest.mark.asyncio
+class TestReadFileTool:
+    async def test_read_entire_file(self, read_file_tool, sample_file):
+        content = await read_file_tool.read_entire_file("test.txt")
+        expected = "# test.txt\n\n```\nLine 1\nLine 2\nLine 3\nLine 4\nLine 5\n```"
+        assert content == expected
+
+    async def test_read_entire_file_not_found(self, read_file_tool):
+        with pytest.raises(FileNotFoundError) as exc_info:
+            await read_file_tool.read_entire_file("nonexistent.txt")
+        assert str(exc_info.value) == "File not found: nonexistent.txt"
+
+    async def test_read_file_section(self, read_file_tool, sample_file):
+        content = await read_file_tool.read_file_section("test.txt", 2, 4)
+        expected = "# test.txt (lines 2-4)\n\n```\nLine 2\nLine 3\nLine 4\n\n```"
+        assert content == expected
+
+    async def test_read_file_section_single_line(self, read_file_tool, sample_file):
+        content = await read_file_tool.read_file_section("test.txt", 1, 1)
+        expected = "# test.txt (lines 1-1)\n\n```\nLine 1\n\n```"
+        assert content == expected
+
+    async def test_read_file_section_not_found(self, read_file_tool):
+        with pytest.raises(FileNotFoundError) as exc_info:
+            await read_file_tool.read_file_section("nonexistent.txt", 1, 1)
+        assert str(exc_info.value) == "File not found: nonexistent.txt"
+
+    async def test_read_file_section_invalid_start_line(self, read_file_tool, sample_file):
+        with pytest.raises(ValueError) as exc_info:
+            await read_file_tool.read_file_section("test.txt", 0, 1)
+        assert str(exc_info.value) == "Start line must be at least 1, got 0"
+
+    async def test_read_file_section_invalid_end_line(self, read_file_tool, sample_file):
+        with pytest.raises(ValueError) as exc_info:
+            await read_file_tool.read_file_section("test.txt", 3, 2)
+        assert str(exc_info.value) == "End line (2) must be greater than or equal to start line (3)"
+
+    async def test_read_file_section_start_line_exceeds_file_length(self, read_file_tool, sample_file):
+        with pytest.raises(ValueError) as exc_info:
+            await read_file_tool.read_file_section("test.txt", 6, 6)
+        assert str(exc_info.value) == "Start line 6 exceeds file length 5"
+
+    async def test_read_file_section_end_line_exceeds_file_length(self, read_file_tool, sample_file):
+        content = await read_file_tool.read_file_section("test.txt", 4, 10)
+        expected = "# test.txt (lines 4-5)\n\n```\nLine 4\nLine 5\n```"
+        assert content == expected
+
+    async def test_read_entire_file_truncation(self, read_file_tool, project_path):
+        """Test that files over 2000 lines are truncated with a warning."""
+        # Create a large file with 2500 lines
+        large_file_path = project_path / "large_file.txt"
+        lines = [f"Line {i}\n" for i in range(1, 2501)]
+        large_file_path.write_text("".join(lines))
+
+        content = await read_file_tool.read_entire_file("large_file.txt")
+
+        # Check that the response indicates truncation
+        assert "# large_file.txt (TRUNCATED)" in content
+        assert "⚠️ File truncated: Showing first 2000 of 2500 lines" in content
+        assert "To read specific sections, use `read_file_section`" in content
+
+        # Verify that only 2000 lines are included
+        # Count the actual lines in the code block
+        code_block_start = content.find("```\n") + 4
+        code_block_end = content.rfind("\n```")
+        code_content = content[code_block_start:code_block_end]
+        actual_lines = code_content.strip().split("\n")
+        assert len(actual_lines) == 2000
+        assert actual_lines[0] == "Line 1"
+        assert actual_lines[-1] == "Line 2000"
+
+    async def test_read_entire_file_char_truncation(self, read_file_tool, project_path):
+        large_file_path = project_path / "large_one_line.html"
+        large_file_path.write_text("a" * 100_050)
+
+        content = await read_file_tool.read_entire_file("large_one_line.html")
+
+        assert "# large_one_line.html (TRUNCATED)" in content
+        assert "File truncated by size: Showing first 100,000 of 100,050 characters" in content
+        code_content = content.split("```\n", 1)[1].rsplit("\n```", 1)[0]
+        assert len(code_content) == 100_000
+
+    async def test_read_file_section_char_truncation(self, read_file_tool, project_path):
+        large_file_path = project_path / "large_section.txt"
+        large_file_path.write_text(("a" * 30_000 + "\n") * 5)
+
+        content = await read_file_tool.read_file_section("large_section.txt", 1, 5)
+
+        assert "# large_section.txt (lines 1-5) (TRUNCATED)" in content
+        assert "File truncated by size" in content
+        code_content = content.split("```\n", 1)[1].rsplit("\n```", 1)[0]
+        assert len(code_content) == 100_000
+
+    async def test_read_entire_file_exactly_at_limit(self, read_file_tool, project_path):
+        """Test that files with exactly 2000 lines are not truncated."""
+        # Create a file with exactly 2000 lines
+        exact_limit_file_path = project_path / "exact_limit_file.txt"
+        lines = [f"Line {i}\n" for i in range(1, 2001)]
+        exact_limit_file_path.write_text("".join(lines))
+
+        content = await read_file_tool.read_entire_file("exact_limit_file.txt")
+
+        # Check that the response does NOT indicate truncation
+        assert "# exact_limit_file.txt\n\n```" in content
+        assert "(TRUNCATED)" not in content
+        assert "⚠️ File truncated" not in content
+
+    async def test_read_entire_file_below_limit(self, read_file_tool, project_path):
+        """Test that files with fewer than 2000 lines are not truncated."""
+        # Create a file with 1999 lines
+        below_limit_file_path = project_path / "below_limit_file.txt"
+        lines = [f"Line {i}\n" for i in range(1, 2000)]
+        below_limit_file_path.write_text("".join(lines))
+
+        content = await read_file_tool.read_entire_file("below_limit_file.txt")
+
+        # Check that the response does NOT indicate truncation
+        assert "# below_limit_file.txt\n\n```" in content
+        assert "(TRUNCATED)" not in content
+        assert "⚠️ File truncated" not in content

kolega_code/agent/tests/tool_backend/test_replace_entire_file_tool.py

@@ -0,0 +1,115 @@
+from unittest.mock import AsyncMock, Mock, patch
+
+import pytest
+import uuid
+
+from kolega_code.config import AgentConfig, ModelConfig, ModelProvider, RateLimitConfig
+from kolega_code.agent.tool_backend.replace_entire_file_tool import ReplaceEntireFileTool
+
+
+@pytest.fixture
+def mock_connection_manager():
+    return AsyncMock()
+
+
+@pytest.fixture
+def project_path(tmp_path):
+    return tmp_path
+
+
+@pytest.fixture
+def agent_config():
+    return AgentConfig(
+        anthropic_api_key="test_key",
+        openai_api_key="test-key",
+        long_context_config=ModelConfig(
+            provider=ModelProvider.ANTHROPIC, model="test-model", rate_limits=RateLimitConfig()
+        ),
+        fast_config=ModelConfig(provider=ModelProvider.ANTHROPIC, model="test-model", rate_limits=RateLimitConfig()),
+        thinking_config=ModelConfig(
+            provider=ModelProvider.ANTHROPIC, model="test-model", rate_limits=RateLimitConfig(), thinking_tokens=1024
+        ),
+    )
+
+
+@pytest.fixture
+def mock_base_agent():
+    mock = Mock()
+    mock.agent_name = "test_agent"
+    return mock
+
+
+@pytest.fixture
+def replace_entire_file_tool(project_path, mock_connection_manager, agent_config, mock_base_agent):
+    return ReplaceEntireFileTool(
+        project_path, "test_workspace", str(uuid.uuid4()), mock_connection_manager, agent_config, mock_base_agent
+    )
+
+
+@pytest.fixture
+def sample_file(project_path):
+    file_path = project_path / "test.txt"
+    file_path.write_text("Original content\nLine 2\nLine 3")
+    return file_path
+
+
+@pytest.mark.asyncio
+class TestReplaceEntireFileTool:
+    async def test_replace_entire_file_success(self, replace_entire_file_tool, sample_file):
+        new_content = "New content\nLine 2\nLine 3"
+        result = await replace_entire_file_tool.replace_entire_file("test.txt", new_content)
+
+        assert result == "# test.txt has been replaced."
+        assert sample_file.read_text() == new_content
+
+    async def test_replace_entire_file_with_empty_content(self, replace_entire_file_tool, sample_file):
+        result = await replace_entire_file_tool.replace_entire_file("test.txt", "")
+
+        assert result == "# test.txt has been replaced."
+        assert sample_file.read_text() == ""
+
+    async def test_replace_entire_file_with_multiline_content(self, replace_entire_file_tool, sample_file):
+        new_content = "Line 1\n\nLine 3\n\nLine 5"
+        result = await replace_entire_file_tool.replace_entire_file("test.txt", new_content)
+
+        assert result == "# test.txt has been replaced."
+        assert sample_file.read_text() == new_content
+
+    async def test_replace_entire_file_file_not_found(self, replace_entire_file_tool):
+        with pytest.raises(FileNotFoundError) as exc_info:
+            await replace_entire_file_tool.replace_entire_file("nonexistent.txt", "Content")
+        assert str(exc_info.value) == "File not found: nonexistent.txt"
+
+    @patch("pathlib.Path.write_text")
+    async def test_replace_entire_file_permission_error(self, mock_write_text, replace_entire_file_tool, sample_file):
+        mock_write_text.side_effect = PermissionError("Permission denied")
+
+        with pytest.raises(PermissionError) as exc_info:
+            await replace_entire_file_tool.replace_entire_file("test.txt", "Content")
+        assert str(exc_info.value) == "Permission denied"
+
+    @patch("pathlib.Path.write_text")
+    async def test_replace_entire_file_general_error(self, mock_write_text, replace_entire_file_tool, sample_file):
+        mock_write_text.side_effect = Exception("Unexpected error")
+
+        with pytest.raises(Exception) as exc_info:
+            await replace_entire_file_tool.replace_entire_file("test.txt", "Content")
+        assert str(exc_info.value) == "Unexpected error"
+
+    async def test_replace_entire_file_preserve_newline(self, replace_entire_file_tool, project_path):
+        # Create a file with a trailing newline
+        file_path = project_path / "newline.txt"
+        file_path.write_text("Line 1\nLine 2\n")
+
+        new_content = "New Line 1\nNew Line 2\n"
+        result = await replace_entire_file_tool.replace_entire_file("newline.txt", new_content)
+
+        assert result == "# newline.txt has been replaced."
+        assert file_path.read_text() == new_content
+
+    async def test_replace_entire_file_with_special_characters(self, replace_entire_file_tool, sample_file):
+        new_content = "Special chars: !@#$%^&*()\nUnicode: 🚀\nTabs:\t\t\t\n"
+        result = await replace_entire_file_tool.replace_entire_file("test.txt", new_content)
+
+        assert result == "# test.txt has been replaced."
+        assert sample_file.read_text() == new_content