kolega-code 0.1.0__py3-none-any.whl

kolega_code/agent/tool_backend/memory_tool.py

@@ -0,0 +1,79 @@
+from .base_tool import BaseTool
+
+
+class MemoryTool(BaseTool):
+    async def read_memory(self) -> str:
+        """
+        Read the contents of the KOLEGA.md file which serves as the agent's memory.
+
+        Returns:
+            The contents of the KOLEGA.md file as a string
+
+        Raises:
+            FileNotFoundError: If the KOLEGA.md file doesn't exist
+        """
+        memory_file = "KOLEGA.md"
+
+        if not self.filesystem.exists(memory_file):
+            error_msg = "Memory file KOLEGA.md not found in project root"
+            await self.log_error(error_msg, sender=self.caller.agent_name)
+            raise FileNotFoundError(error_msg)
+
+        try:
+            memory_content = self.filesystem.read_text(memory_file)
+
+            await self.log_info("Successfully read memory file KOLEGA.md", sender=self.caller.agent_name)
+            return memory_content
+        except PermissionError:
+            error_msg = "Permission denied when reading memory file KOLEGA.md"
+            await self.log_error(error_msg, sender=self.caller.agent_name)
+            raise
+        except Exception as e:
+            error_msg = f"Failed to read memory file KOLEGA.md: {str(e)}"
+            await self.log_error(error_msg, sender=self.caller.agent_name)
+            raise
+
+    async def write_memory(self, memory_content: str) -> str:
+        """
+        Write a new memory to the KOLEGA.md file which serves as the agent's memory.
+
+        The memory is added as a markdown bullet point to the file.
+
+        Args:
+            memory_content: The memory content to add to the file
+
+        Returns:
+            A confirmation message indicating success
+
+        Raises:
+            PermissionError: If the file cannot be written to
+            Exception: If any other error occurs during writing
+        """
+        memory_file = "KOLEGA.md"
+
+        try:
+            # Create the file if it doesn't exist
+            if not self.filesystem.exists(memory_file):
+                self.filesystem.write_text(memory_file, f"# KOLEGA Memory\n\n- {memory_content}\n")
+                success_msg = "Created memory file KOLEGA.md and added new memory"
+            else:
+                # Read existing content and append the new memory
+                existing_content = self.filesystem.read_text(memory_file)
+
+                # Add the new memory as a bullet point
+                updated_content = f"{existing_content.rstrip()}\n- {memory_content}\n"
+
+                # Write the updated content back to the file
+                self.filesystem.write_text(memory_file, updated_content)
+                success_msg = "Successfully added new memory to KOLEGA.md"
+
+            await self.log_info(success_msg, sender=self.caller.agent_name)
+            return success_msg
+        except PermissionError:
+            error_msg = "Permission denied when writing to memory file KOLEGA.md"
+            await self.log_error(error_msg, sender=self.caller.agent_name)
+            raise
+        except Exception as e:
+            error_msg = f"Failed to write to memory file KOLEGA.md: {str(e)}"
+            await self.log_error(error_msg, sender=self.caller.agent_name)
+            raise

kolega_code/agent/tool_backend/read_file_tool.py

@@ -0,0 +1,119 @@
+from .base_tool import BaseTool
+
+
+class ReadFileTool(BaseTool):
+    MAX_LINES_FOR_ENTIRE_FILE = 2000
+    MAX_CHARS_FOR_FILE_OUTPUT = 100_000
+
+    def _format_file_content(
+        self,
+        relative_path: str,
+        content: str,
+        *,
+        line_range: str = "",
+        line_truncation_notice: str = "",
+    ) -> str:
+        original_char_count = len(content)
+        char_truncated = original_char_count > self.MAX_CHARS_FOR_FILE_OUTPUT
+        if char_truncated:
+            content = content[: self.MAX_CHARS_FOR_FILE_OUTPUT]
+
+        truncated = bool(line_truncation_notice) or char_truncated
+        suffix_parts = []
+        if line_range:
+            suffix_parts.append(line_range)
+        if truncated:
+            suffix_parts.append("(TRUNCATED)")
+        suffix = f" {' '.join(suffix_parts)}" if suffix_parts else ""
+
+        notices = []
+        if line_truncation_notice:
+            notices.append(line_truncation_notice)
+        if char_truncated:
+            notices.append(
+                f"**File truncated by size: Showing first {self.MAX_CHARS_FOR_FILE_OUTPUT:,} "
+                f"of {original_char_count:,} characters**"
+            )
+        if notices:
+            notices.append("To read specific sections, use `read_file_section` with start/end line numbers.")
+
+        notice_text = "\n\n".join(notices)
+        if notice_text:
+            notice_text += "\n\n"
+
+        return f"# {relative_path}{suffix}\n\n{notice_text}```\n{content}\n```"
+
+    async def read_entire_file(self, relative_path: str) -> str:
+        """
+        Read the contents of a file in the project.
+
+        Note: Files exceeding 2000 lines will be truncated with a warning message.
+        Use read_file_section to read specific portions of large files.
+
+        Args:
+            relative_path: Path to the file, relative to the project root
+
+        Returns:
+            The contents of the file as a string formatted as markdown.
+            If the file exceeds 2000 lines, returns a truncated version with a warning.
+
+        Raises:
+            FileNotFoundError: If the file doesn't exist
+        """
+        if not self.filesystem.exists(relative_path):
+            raise FileNotFoundError(f"File not found: {relative_path}")
+
+        file_content = self.filesystem.read_text(relative_path)
+        lines = file_content.splitlines(keepends=True)
+        total_lines = len(lines)
+
+        if total_lines > self.MAX_LINES_FOR_ENTIRE_FILE:
+            # Truncate the content to the maximum allowed lines
+            truncated_lines = lines[: self.MAX_LINES_FOR_ENTIRE_FILE]
+            truncated_content = "".join(truncated_lines)
+
+            return self._format_file_content(
+                relative_path,
+                truncated_content,
+                line_truncation_notice=(
+                    f"**⚠️ File truncated: Showing first {self.MAX_LINES_FOR_ENTIRE_FILE} of {total_lines} lines**"
+                ),
+            )
+
+        return self._format_file_content(relative_path, file_content)
+
+    async def read_file_section(self, relative_path: str, start_line: int, end_line: int) -> str:
+        """
+        Read a specific section of a file in the project from start_line to end_line (inclusive).
+
+        Args:
+            relative_path: Path to the file, relative to the project root
+            start_line: The line number to start reading from (1-indexed)
+            end_line: The line number to stop reading at (1-indexed, inclusive)
+
+        Returns:
+            The specified section of the file as a string formatted as markdown
+
+        Raises:
+            FileNotFoundError: If the file doesn't exist
+            ValueError: If start_line or end_line are invalid
+        """
+        if not self.filesystem.exists(relative_path):
+            raise FileNotFoundError(f"File not found: {relative_path}")
+
+        if start_line < 1:
+            raise ValueError(f"Start line must be at least 1, got {start_line}")
+
+        if end_line < start_line:
+            raise ValueError(f"End line ({end_line}) must be greater than or equal to start line ({start_line})")
+
+        file_content = self.filesystem.read_text(relative_path)
+        lines = file_content.splitlines(keepends=True)
+
+        if start_line > len(lines):
+            raise ValueError(f"Start line {start_line} exceeds file length {len(lines)}")
+
+        # Adjust for 0-indexed list
+        section_content = "".join(lines[start_line - 1 : end_line])
+        line_range = f"(lines {start_line}-{min(end_line, len(lines))})"
+        return self._format_file_content(relative_path, section_content, line_range=line_range)

kolega_code/agent/tool_backend/replace_entire_file_tool.py

@@ -0,0 +1,40 @@
+from .base_tool import BaseTool
+
+
+class ReplaceEntireFileTool(BaseTool):
+    async def replace_entire_file(self, relative_path: str, content: str) -> str:
+        """
+        Replace the entire contents of a file in the project.
+
+        Args:
+            relative_path: Path to the file, relative to the project root
+            content: New content to write to the file
+
+        Returns:
+            The updated contents of the file as a string formatted as markdown
+
+        Raises:
+            FileNotFoundError: If the file doesn't exist
+            PermissionError: If the file cannot be written to
+        """
+        if not self.filesystem.exists(relative_path):
+            error_msg = f"File not found: {relative_path}"
+            await self.log_error(error_msg, sender=self.caller.agent_name)
+            raise FileNotFoundError(error_msg)
+
+        try:
+            blocked_msg = self._enforce_vibe_edit_policy(relative_path)
+            if blocked_msg:
+                return blocked_msg
+            self.filesystem.write_text(relative_path, content)
+            success_msg = f"Successfully replaced file: {relative_path}"
+            await self.log_info(success_msg, sender=self.caller.agent_name)
+            return f"# {relative_path} has been replaced."
+        except PermissionError as e:
+            error_msg = f"Permission denied when writing to file: {relative_path}"
+            await self.log_error(error_msg, sender=self.caller.agent_name)
+            raise
+        except Exception as e:
+            error_msg = f"Failed to write to file {relative_path}: {str(e)}"
+            await self.log_error(error_msg, sender=self.caller.agent_name)
+            raise

kolega_code/agent/tool_backend/replace_lines_tool.py

@@ -0,0 +1,97 @@
+from .base_tool import BaseTool
+
+
+class ReplaceLinesTool(BaseTool):
+    async def replace_lines(self, relative_path: str, start_line: int, end_line: int, new_content: str) -> str:
+        """
+        Replace a range of lines in a file with new content.
+
+        Args:
+            relative_path: Path to the file, relative to the project root
+            start_line: The starting line number (1-indexed)
+            end_line: The ending line number (1-indexed, inclusive)
+            new_content: The new content to replace the specified lines with
+
+        Returns:
+            The updated contents of the file as a string formatted as markdown
+
+        Raises:
+            FileNotFoundError: If the file doesn't exist
+            ValueError: If the line range is invalid
+            PermissionError: If the file cannot be written to
+        """
+        if not self.filesystem.exists(relative_path):
+            error_msg = f"File not found: {relative_path}"
+            await self.log_error(error_msg, sender=self.caller.agent_name)
+            raise FileNotFoundError(error_msg)
+
+        if start_line < 1:
+            error_msg = f"Invalid start_line: {start_line}. Line numbers must be 1-indexed."
+            await self.log_error(error_msg, sender=self.caller.agent_name)
+            raise ValueError(error_msg)
+
+        if end_line < start_line:
+            error_msg = (
+                f"Invalid line range: end_line ({end_line}) must be greater than or equal to start_line ({start_line})."
+            )
+            await self.log_error(error_msg, sender=self.caller.agent_name)
+            raise ValueError(error_msg)
+
+        try:
+            # Read the original file content
+            file_content = self.filesystem.read_text(relative_path)
+            lines = file_content.splitlines(keepends=True)
+
+            # Check if the line range is valid
+            if start_line > len(lines):
+                error_msg = f"Invalid start_line: {start_line}. File only has {len(lines)} lines."
+                await self.log_error(error_msg, sender=self.caller.agent_name)
+                raise ValueError(error_msg)
+
+            # Convert to 0-indexed for internal processing
+            start_idx = start_line - 1
+            end_idx = min(end_line, len(lines))
+
+            # Store the old content before replacing
+            old_content = "".join(lines[start_idx:end_idx])
+
+            # Handle newlines
+            new_content_lines = new_content.splitlines()
+            if not new_content_lines:
+                # Empty content case
+                formatted_new_content = "\n" if end_idx < len(lines) else ""
+            else:
+                # Non-empty content case
+                formatted_new_content = "\n".join(new_content_lines)
+                if end_idx < len(lines) or (lines and lines[-1].endswith("\n")):
+                    formatted_new_content += "\n"
+
+            # Replace the specified lines
+            updated_content = "".join(lines[:start_idx]) + formatted_new_content + "".join(lines[end_idx:])
+
+            # Write the updated content back to the file (with vibe policy enforcement)
+            blocked_msg = self._enforce_vibe_edit_policy(relative_path)
+            if blocked_msg:
+                return blocked_msg
+            self.filesystem.write_text(relative_path, updated_content)
+
+            success_msg = f"Successfully replaced lines {start_line}-{end_line} in file: {relative_path}"
+            await self.log_info(success_msg, sender=self.caller.agent_name)
+
+            # Return the formatted message with both old and new content
+            return (
+                f"Replaced lines {start_line}-{end_line} in file {relative_path}\n\n"
+                f"Replaced:\n"
+                f"```\n{old_content}```\n"
+                f"with:\n"
+                f"```\n{formatted_new_content}```"
+            )
+
+        except PermissionError:
+            error_msg = f"Permission denied when writing to file: {relative_path}"
+            await self.log_error(error_msg, sender=self.caller.agent_name)
+            raise
+        except Exception as e:
+            error_msg = f"Failed to replace lines in file {relative_path}: {str(e)}"
+            await self.log_error(error_msg, sender=self.caller.agent_name)
+            raise

kolega_code/agent/tool_backend/search_and_replace_tool.py

@@ -0,0 +1,146 @@
+import re
+
+from .base_tool import BaseTool
+
+
+class SearchAndReplaceTool(BaseTool):
+    async def search_and_replace(self, relative_path: str, blocks: str) -> str:
+        """
+        Edit a file using search and replace blocks.
+
+        The blocks should be formatted as follows:
+        ```
+        <<<<<<< SEARCH
+        [original code to find]
+        =======
+        [new code to replace with]
+        >>>>>>> REPLACE
+        ```
+
+        Multiple search and replace blocks can be provided in sequence.
+        The tool will process each block in order, updating the file incrementally.
+        THE INDENTATION IN THE SEARCH BLOCK MUST BE IDENTICAL TO THE EXISTING FILE.
+
+        Args:
+            relative_path: Path to the file to edit, relative to the project root
+            blocks: One or more search and replace blocks formatted as shown above
+
+        Returns:
+            The updated contents of the file as a string formatted as markdown
+
+        Raises:
+            FileNotFoundError: If the file doesn't exist
+            ValueError: If the search block doesn't match any content in the file
+            ValueError: If the blocks are malformed or incorrectly formatted
+            PermissionError: If the file cannot be written to
+        """
+        if not self.filesystem.exists(relative_path):
+            error_msg = f"File not found: {relative_path}"
+            await self.log_error(error_msg, sender=self.caller.agent_name)
+            raise FileNotFoundError(error_msg)
+
+        try:
+            # Read the original file content
+            file_content = self.filesystem.read_text(relative_path)
+
+            original_content = file_content
+            updated_content = file_content
+
+            # Track all the replacements made for reporting
+            replacements_made = []
+
+            # Parse the search and replace blocks
+            block_pattern = re.compile(r"<<<<<<< SEARCH\n(.*?)\n=======\n(.*?)\n>>>>>>> REPLACE", re.DOTALL)
+
+            matches = list(block_pattern.finditer(blocks))
+
+            if not matches:
+                error_msg = (
+                    "No valid search and replace blocks found. Blocks must follow the format:\n"
+                    "<<<<<<< SEARCH\n[original code]\n=======\n[new code]\n>>>>>>> REPLACE"
+                )
+                await self.log_error(error_msg, sender=self.caller.agent_name)
+                raise ValueError(error_msg)
+
+            # Check if there are multiple search and replace blocks
+            if len(matches) > 1:
+                error_msg = "Multiple search and replace blocks provided. This tool only supports one block at a time."
+                await self.log_error(error_msg, sender=self.caller.agent_name)
+                raise ValueError(error_msg)
+
+            # Process each search and replace block
+            for i, match in enumerate(matches, 1):
+                search_text = match.group(1)
+                replace_text = match.group(2)
+
+                # Validate the search and replace blocks
+                if not search_text.strip():
+                    error_msg = f"Empty search block in block #{i}. Search text cannot be empty."
+                    await self.log_error(error_msg, sender=self.caller.agent_name)
+                    raise ValueError(error_msg)
+
+                # Check if the search text exists in the current content
+                if search_text not in updated_content:
+                    # Get some context around where we expect to find it for better error reporting
+                    error_msg = f"Search block #{i} does not match any content in the file.\nSearch text: '{search_text[:100]}{'...' if len(search_text) > 100 else ''}'"
+                    await self.log_error(error_msg, sender=self.caller.agent_name)
+                    raise ValueError(error_msg)
+
+                # Count occurrences to check for multiple matches
+                occurrences = updated_content.count(search_text)
+                if occurrences > 1:
+                    error_msg = f"Search block #{i} matched {occurrences} occurrences in the file."
+                    await self.log_error(error_msg, sender=self.caller.agent_name)
+                    raise ValueError(error_msg)
+
+                # Track replacement details
+                replacements_made.append(
+                    {
+                        "block_number": i,
+                        "occurrences_replaced": occurrences,
+                        "search_text_preview": search_text[:50] + ("..." if len(search_text) > 50 else ""),
+                        "replace_text_preview": replace_text[:50] + ("..." if len(replace_text) > 50 else ""),
+                    }
+                )
+
+                # Apply the replacement
+                updated_content = updated_content.replace(search_text, replace_text)
+
+            # Check if anything was changed
+            if updated_content == original_content:
+                await self.log_warning(
+                    f"No changes made to {relative_path}. All replacements were identical to original text.",
+                    sender=self.caller.agent_name,
+                )
+                return f"# {relative_path} (No changes made)\n\n```\n{original_content}\n```"
+
+            # Write the updated content back to the file (with vibe policy enforcement)
+            blocked_msg = self._enforce_vibe_edit_policy(relative_path)
+            if blocked_msg:
+                return blocked_msg
+            self.filesystem.write_text(relative_path, updated_content)
+
+            # Extract search and replace text for output
+            search_text = matches[0].group(1)
+            replace_text = matches[0].group(2)
+
+            # Return a message similar to replace_lines tool
+            return (
+                f"Search and replace in file {relative_path}\n\n"
+                f"Replaced:\n"
+                f"```\n{search_text}\n```\n"
+                f"with:\n"
+                f"```\n{replace_text}\n```"
+            )
+
+        except ValueError as e:
+            # Re-raise ValueError exceptions which are used for validation errors
+            raise
+        except PermissionError as e:
+            error_msg = f"Permission denied when writing to file: {relative_path}"
+            await self.log_error(error_msg, sender=self.caller.agent_name)
+            raise
+        except Exception as e:
+            error_msg = f"Failed to apply search and replace to {relative_path}: {str(e)}"
+            await self.log_error(error_msg, sender=self.caller.agent_name)
+            raise