kolega-code 0.1.0__py3-none-any.whl

kolega_code/agent/tool_backend/base_tool.py

@@ -0,0 +1,217 @@
+import os
+from pathlib import Path
+from typing import Union, Optional, Set
+
+from ..common import LogMixin
+from kolega_code.config import AgentConfig
+from kolega_code.events import AgentConnectionManager
+from kolega_code.services.file_system import FileSystem, LocalFileSystem
+from kolega_code.services.base import TerminalManager, BrowserManager
+from ..prompt_provider import AgentMode
+
+
+class BaseTool(LogMixin):
+
+    def __init__(
+        self,
+        project_path: Union[str, Path],
+        workspace_id: str,
+        thread_id: str,
+        connection_manager: AgentConnectionManager,
+        config: AgentConfig,
+        caller,
+        filesystem: Optional[FileSystem] = None,
+        terminal_manager: Optional[TerminalManager] = None,
+        browser_manager: Optional[BrowserManager] = None,
+    ) -> None:
+        self.workspace_id = workspace_id
+        self.thread_id = thread_id
+        self.project_path = Path(project_path) if isinstance(project_path, str) else project_path
+        self.connection_manager = connection_manager
+        self.config = config
+        self.caller = caller
+
+        # Create filesystem instance if not provided
+        if filesystem is None:
+            self.filesystem = LocalFileSystem(root_path=self.project_path)
+        else:
+            self.filesystem = filesystem
+
+        # Store optional managers (individual tools will use them if needed)
+        self.terminal_manager = terminal_manager
+        self.browser_manager = browser_manager
+
+    def _is_binary_file(self, file_path: Path) -> bool:
+        """
+        Determine if a file is binary.
+
+        Args:
+            file_path: Path to the file to check
+
+        Returns:
+            True if the file is binary, False otherwise
+        """
+        # Check file extension for common binary formats
+        binary_extensions = {
+            ".pyc",
+            ".so",
+            ".dll",
+            ".exe",
+            ".bin",
+            ".jar",
+            ".war",
+            ".jpg",
+            ".jpeg",
+            ".png",
+            ".gif",
+            ".bmp",
+            ".ico",
+            ".svg",
+            ".pdf",
+            ".zip",
+            ".tar",
+            ".gz",
+            ".tgz",
+            ".rar",
+            ".7z",
+            ".mp3",
+            ".mp4",
+            ".avi",
+            ".mov",
+            ".mkv",
+            ".wav",
+            ".o",
+            ".obj",
+            ".class",
+            ".binary",
+        }
+
+        if file_path.suffix.lower() in binary_extensions:
+            return True
+
+        # Check file contents (sample the first 1024 bytes)
+        try:
+            with file_path.open("rb") as f:
+                sample = f.read(1024)
+                if b"\x00" in sample:  # If null byte is present, likely binary
+                    return True
+        except Exception:
+            # If there's an error reading the file, consider it binary to be safe
+            return True
+
+        return False
+
+    def _should_exclude_file(self, file_path: Path) -> bool:
+        """
+        Determine if a file should be excluded from search.
+
+        Args:
+            file_path: Path to the file to check
+
+        Returns:
+            True if the file should be excluded, False otherwise
+        """
+        # Common directories to exclude
+        exclude_directories = {
+            ".git",
+            ".svn",
+            ".hg",
+            ".idea",
+            ".vscode",
+            "__pycache__",
+            "node_modules",
+            "venv",
+            "env",
+            ".env",
+            "dist",
+            "build",
+            "target",
+            "bin",
+            "obj",
+        }
+
+        # Check if any parent directory is in the exclude list
+        for parent in file_path.parents:
+            if parent.name in exclude_directories:
+                return True
+
+        # Exclude very large files (> 10MB)
+        try:
+            if file_path.stat().st_size > 10 * 1024 * 1024:  # 10MB
+                return True
+        except Exception:
+            # If we can't get the file size, exclude it to be safe
+            return True
+
+        # Check if file is excluded by .gitignore
+        if self._is_gitignored(file_path):
+            return True
+
+        return False
+
+    def _is_gitignored(self, file_path: Path) -> bool:
+        """
+        Check if a file is excluded by .gitignore patterns.
+
+        Args:
+            file_path: Path to the file to check
+
+        Returns:
+            True if the file is ignored according to .gitignore, False otherwise
+        """
+        # Use cached gitignore patterns if available
+        if not hasattr(self, "_gitignore_spec"):
+            self._load_gitignore_patterns()
+
+        if not hasattr(self, "_gitignore_spec") or self._gitignore_spec is None:
+            return False
+
+        # Get the path relative to the project root
+        relative_path = str(file_path.relative_to(self.project_path))
+
+        # Check if the path matches any gitignore pattern
+        return self._gitignore_spec.match_file(relative_path)
+
+    def _load_gitignore_patterns(self) -> None:
+        """
+        Load .gitignore patterns from the project root.
+        Creates a pathspec matcher that can be used to check if files match gitignore patterns.
+        """
+        try:
+            import pathspec
+
+            if not self.filesystem.exists(".gitignore"):
+                self._gitignore_spec = None
+                return
+
+            gitignore_content = self.filesystem.read_text(".gitignore", encoding="utf-8")
+
+            # Parse gitignore patterns
+            self._gitignore_spec = pathspec.PathSpec.from_lines(
+                pathspec.patterns.GitWildMatchPattern, gitignore_content.splitlines()
+            )
+        except Exception as e:
+            # If there's an error loading gitignore, log it and continue without gitignore filtering
+            print(f"Error loading .gitignore: {str(e)}")
+            self._gitignore_spec = None
+
+    # --- Vibe-mode edit policy helpers ---
+    def _is_vibe_mode(self) -> bool:
+        """Return True if caller agent is in VIBE mode (same check pattern as agents)."""
+        return getattr(self.caller, "agent_mode", None) == AgentMode.VIBE.value
+
+    def _get_vibe_blacklist_basenames(self) -> Set[str]:
+        """Basename blacklist for files that should not be edited in vibe mode."""
+        protected_files = getattr(self.caller, "protected_files", None) if self.caller else None
+        if protected_files:
+            return set(protected_files)
+        return {"package.json", "tsconfig.json"}
+
+    def _enforce_vibe_edit_policy(self, relative_path: str) -> Optional[str]:
+        """Return message if blocked; None if allowed."""
+        if not self._is_vibe_mode():
+            return None
+
+        if os.path.basename(relative_path) in self._get_vibe_blacklist_basenames():
+            return f"You are not allowed to edit this file: {relative_path}"
+        return None

kolega_code/agent/tool_backend/browser_tool.py

@@ -0,0 +1,271 @@
+from pathlib import Path
+from typing import Union
+
+from kolega_code.config import AgentConfig
+from kolega_code.events import AgentEvent
+from kolega_code.services.browser import PlaywrightBrowserManager
+from .base_tool import BaseTool
+
+
+class BrowserTool(BaseTool):
+    MAX_HTML_CHARS_FOR_CONTENT_OUTPUT = 100_000
+
+    def __init__(
+        self,
+        project_path: Union[str, Path],
+        workspace_id: str,
+        thread_id: str,
+        connection_manager,
+        config: AgentConfig,
+        caller,
+        filesystem=None,
+        browser_manager=None,
+    ):
+        super().__init__(
+            project_path,
+            workspace_id,
+            thread_id,
+            connection_manager,
+            config,
+            caller,
+            filesystem,
+            browser_manager=browser_manager,
+        )
+
+        # Use injected browser_manager if provided, otherwise create local one
+        if self.browser_manager is None:
+            self.browser_manager = PlaywrightBrowserManager()
+
+    async def launch_browser(self, url: str) -> str:
+        browser_result = await self.browser_manager.launch_browser(url)
+
+        # Check if we got an error dict instead of a browser ID
+        if isinstance(browser_result, dict) and "error" in browser_result:
+            return f"Failed to launch browser. Error: {browser_result['error']}"
+
+        if browser_result:
+            browser_launched_event = AgentEvent(
+                event_type="browser_launched", sender=self.caller.agent_name, content={"browser_id": browser_result}
+            )
+            await self.connection_manager.broadcast_event(browser_launched_event, self.workspace_id, self.thread_id)
+
+            return f"Launched new browser with browser_id {browser_result}"
+        else:
+            return f"Failed to launch browser."
+
+    async def list_browsers(self):
+        results = await self.browser_manager.list_browsers()
+
+        if not results:
+            return "No browsers are currently running."
+
+        markdown_output = "# Running Browsers\n\n"
+        markdown_output += "| Browser ID | URL | Launched At |\n"
+        markdown_output += "|------------|-----|------------|\n"
+
+        for browser_id, browser_info in results.items():
+            url = browser_info.get("url", "N/A")
+            launched_at = browser_info.get("launched_at", "N/A")
+            markdown_output += f"| {browser_id} | {url} | {launched_at} |\n"
+
+        return markdown_output
+
+    async def get_browser_console_logs(
+        self,
+        browser_id: str,
+        max_logs: int = 50,
+        log_types: list = None,
+        minutes_back: int = None,
+        max_chars: int = 8000,
+    ) -> str:
+        logs = await self.browser_manager.get_browser_console_logs(
+            browser_id, max_logs=max_logs, log_types=log_types, minutes_back=minutes_back, max_chars=max_chars
+        )
+
+        if not logs["console_logs"]:
+            return "## Console Logs\n\nNo console logs found."
+
+        # Add metadata about filtering
+        markdown_output = "## Console Logs\n\n"
+        markdown_output += f"**Showing {logs['returned_count']} of {logs['total_logs_count']} total logs**\n\n"
+
+        filters_applied = logs["filters_applied"]
+        if filters_applied["log_types"]:
+            markdown_output += f"**Filtered by types:** {', '.join(filters_applied['log_types'])}\n"
+        if filters_applied["minutes_back"]:
+            markdown_output += f"**Time window:** Last {filters_applied['minutes_back']} minutes\n"
+        if filters_applied["max_chars"]:
+            markdown_output += f"**Character limit:** {filters_applied['max_chars']}\n"
+        markdown_output += f"**Max logs:** {filters_applied['max_logs']}\n\n"
+
+        markdown_output += "| Type | Timestamp | Message | Location |\n"
+        markdown_output += "|------|-----------|---------|----------|\n"
+
+        for log in logs["console_logs"]:
+            log_type = log.get("type", "unknown")
+            timestamp = log.get("timestamp", "N/A")
+            text = log.get("text", "").replace("|", "\\|")  # Escape pipe characters for markdown tables
+            location = log.get("location", "N/A")
+            if location and location != "N/A":
+                location_str = f"{location.get('url', 'unknown')}:{location.get('lineNumber', '?')}:{location.get('columnNumber', '?')}"
+            else:
+                location_str = "N/A"
+            markdown_output += f"| {log_type} | {timestamp} | {text} | {location_str} |\n"
+
+        return markdown_output
+
+    async def get_browser_interactive_elements(self, browser_id: str) -> str:
+        result = await self.browser_manager.get_browser_interactive_elements(browser_id)
+
+        # Format the interactive elements as markdown
+        markdown_output = f"# Interactive Elements: {result['title']}\n\n"
+        markdown_output += f"**Current URL:** {result['current_url']}\n\n"
+
+        if result["interactive_elements"]:
+            markdown_output += "## Elements\n\n"
+            markdown_output += "| Type | Text | Selector | Attributes |\n"
+            markdown_output += "|------|------|----------|------------|\n"
+
+            for element in result["interactive_elements"]:
+                element_type = element.get("element_type", "unknown")
+                text = element.get("text", "").replace("|", "\\|")  # Escape pipe characters for markdown tables
+                selector = element.get("selector", "").replace("|", "\\|")
+                attributes = str(element.get("attributes", {})).replace("|", "\\|")
+
+                markdown_output += f"| {element_type} | {text} | `{selector}` | {attributes} |\n"
+        else:
+            markdown_output += "No interactive elements found on the page."
+
+        return markdown_output
+
+    async def get_browser_content(
+        self,
+        browser_id: str,
+        max_logs: int = 50,
+        log_types: list = None,
+        minutes_back: int = None,
+        max_chars: int = 8000,
+    ) -> str:
+        content = await self.browser_manager.get_browser_content(
+            browser_id, max_logs=max_logs, log_types=log_types, minutes_back=minutes_back, max_chars=max_chars
+        )
+
+        # Format the browser content as markdown
+        markdown_output = f"# Browser Content: {content['title']}\n\n"
+        markdown_output += f"**Current URL:** {content['current_url']}\n\n"
+
+        # Add console logs section if there are any
+        if content["console_logs"]:
+            markdown_output += "## Console Logs\n\n"
+
+            # Add metadata about console log filtering
+            if "console_log_metadata" in content:
+                metadata = content["console_log_metadata"]
+                markdown_output += (
+                    f"**Showing {metadata['returned_count']} of {metadata['total_logs_count']} total logs**\n\n"
+                )
+
+                filters_applied = metadata["filters_applied"]
+                if filters_applied["log_types"]:
+                    markdown_output += f"**Filtered by types:** {', '.join(filters_applied['log_types'])}\n"
+                if filters_applied["minutes_back"]:
+                    markdown_output += f"**Time window:** Last {filters_applied['minutes_back']} minutes\n"
+                if filters_applied["max_chars"]:
+                    markdown_output += f"**Character limit:** {filters_applied['max_chars']}\n"
+                markdown_output += f"**Max logs:** {filters_applied['max_logs']}\n\n"
+
+            markdown_output += "| Type | Timestamp | Message | Location |\n"
+            markdown_output += "|------|-----------|---------|----------|\n"
+
+            for log in content["console_logs"]:
+                log_type = log.get("type", "unknown")
+                timestamp = log.get("timestamp", "N/A")
+                text = log.get("text", "").replace("|", "\\|")  # Escape pipe characters for markdown tables
+                location = log.get("location", "N/A")
+                if location and location != "N/A":
+                    location_str = f"{location.get('url', 'unknown')}:{location.get('lineNumber', '?')}:{location.get('columnNumber', '?')}"
+                else:
+                    location_str = "N/A"
+                markdown_output += f"| {log_type} | {timestamp} | {text} | {location_str} |\n"
+
+        # Add HTML content in a code block
+        html = content["html"]
+        original_html_chars = len(html)
+        html_truncated = original_html_chars > self.MAX_HTML_CHARS_FOR_CONTENT_OUTPUT
+        if html_truncated:
+            html = html[: self.MAX_HTML_CHARS_FOR_CONTENT_OUTPUT]
+
+        markdown_output += "\n## Page HTML\n\n"
+        if html_truncated:
+            markdown_output += (
+                f"**HTML truncated by size: Showing first {self.MAX_HTML_CHARS_FOR_CONTENT_OUTPUT:,} "
+                f"of {original_html_chars:,} characters.**\n\n"
+            )
+        markdown_output += "```html\n"
+        markdown_output += html
+        markdown_output += "\n```\n"
+
+        return markdown_output
+
+    async def take_browser_screenshot(self, browser_id: str) -> dict:
+        return await self.browser_manager.take_browser_screenshot(browser_id)
+
+    async def interact_with_browser(
+        self, browser_id: str, action: str, selector: str, text: str, scroll_px: int
+    ) -> str:
+        result = await self.browser_manager.interact_with_browser(browser_id, action, selector, text, scroll_px)
+
+        # Format the interaction result as markdown
+        markdown_output = f"# Browser Interaction Result\n\n"
+        markdown_output += f"**Status:** {result['status']}\n"
+        markdown_output += f"**Current URL:** {result['current_url']}\n\n"
+        markdown_output += f"**Action Performed:** {result['action']}\n"
+
+        if result["selector"]:
+            markdown_output += f"**Selector:** `{result['selector']}`\n"
+
+        if result["text"]:
+            markdown_output += f"**Text/URL:** {result['text']}\n"
+
+        return markdown_output
+
+    async def set_browser_select_value(self, browser_id: str, selector: str, value: str) -> str:
+        result = await self.browser_manager.set_select_value(browser_id, selector, value)
+
+        # Format the select value result as markdown
+        markdown_output = f"# Select Value Update Result\n\n"
+        markdown_output += f"**Status:** {result['status']}\n"
+        markdown_output += f"**Current URL:** {result['current_url']}\n"
+        markdown_output += f"**Selector:** `{result['selector']}`\n\n"
+
+        if result["status"] == "success":
+            markdown_output += "## ✅ Success\n\n"
+            markdown_output += f"**Requested Value:** `{result['requested_value']}`\n"
+            markdown_output += f"**Selected Value:** `{result['selected_value']}`\n"
+
+            if result["requested_value"] == result["selected_value"]:
+                markdown_output += "\n✓ The select box value was successfully updated."
+            else:
+                markdown_output += "\n⚠️ Warning: The selected value differs from the requested value."
+        else:
+            markdown_output += "## ❌ Error\n\n"
+            markdown_output += f"**Error Message:** {result.get('error', 'Unknown error')}\n"
+
+        return markdown_output
+
+    async def close_browser(self, browser_id) -> str:
+        await self.browser_manager.close_browser(browser_id)
+
+        browser_closed_event = AgentEvent(
+            event_type="browser_closed", sender=self.caller.agent_name, content={"browser_id": browser_id}
+        )
+        await self.connection_manager.broadcast_event(browser_closed_event, self.workspace_id, self.thread_id)
+
+        return f"Browser with ID {browser_id} closed."
+
+    async def cleanup(self) -> None:
+        """
+        Clean up all browser resources.
+        This should be called when the tool is being destroyed.
+        """
+        await self.browser_manager.cleanup_all_browsers()

kolega_code/agent/tool_backend/build_tool.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from typing import Optional
+
+import yaml
+
+from .base_tool import BaseTool
+
+
+class BuildTool(BaseTool):
+    """
+    Provides backend and frontend build operations driven by .kolega-manifest.yaml.
+
+    Resolves the appropriate build command and executes it via the injected
+    TerminalManager so it works in both local and sandbox environments.
+    """
+
+    def _read_manifest(self) -> dict:
+        """
+        Read the project manifest from the repository root.
+
+        Returns an empty dict when the file is missing or invalid.
+        """
+        manifest_path = ".kolega-manifest.yaml"
+        try:
+            if not self.filesystem.exists(manifest_path):
+                return {}
+            content = self.filesystem.read_text(manifest_path)
+            data = yaml.safe_load(content) or {}
+            return data if isinstance(data, dict) else {}
+        except Exception:
+            return {}
+
+    @staticmethod
+    def _get_build_command(manifest: dict, kind: str) -> Optional[str]:
+        """
+        Resolve the build command from the manifest.
+
+        kind: 'backend' | 'frontend'
+        """
+        if not isinstance(manifest, dict):
+            return None
+        if kind == "backend":
+            return manifest.get("backend_build_command") or manifest.get("build_command")
+        if kind == "frontend":
+            return manifest.get("frontend_build_command") or manifest.get("build_command")
+        return None
+
+    async def _run_build(self, kind: str) -> str:
+        """
+        Execute the resolved build command and return markdown-formatted output.
+        """
+        manifest = self._read_manifest()
+        command = self._get_build_command(manifest, kind)
+
+        if not command:
+            return f"Error: No {kind}_build_command or build_command found in .kolega-manifest.yaml"
+
+        try:
+            output = await self.terminal_manager.run_command(
+                command=command,
+                cwd=str(self.project_path),
+                timeout=1800,
+            )
+        except Exception as exc:
+            return f"Build failed to start: {str(exc)}"
+
+        return f"""Ran {kind} build command:
+
+```
+{command}
+```
+
+Output:
+```
+{output}
+```"""
+
+    async def build_backend(self) -> str:
+        """
+        Build the backend using the manifest command (backend_build_command → build_command).
+
+        Returns the combined stdout/stderr output as markdown.
+        """
+        return await self._run_build("backend")
+
+    async def build_frontend(self) -> str:
+        """
+        Build the frontend using the manifest command (frontend_build_command → build_command).
+
+        Returns the combined stdout/stderr output as markdown.
+        """
+        return await self._run_build("frontend")

kolega_code/agent/tool_backend/create_file_tool.py

@@ -0,0 +1,52 @@
+from .base_tool import BaseTool
+
+
+class CreateFileTool(BaseTool):
+    async def create_file(self, relative_path: str, content: str) -> str:
+        """
+        Create a new file with the specified content.
+
+        Args:
+            relative_path: Path to create the file at, relative to the project root
+            content: Content to write to the file
+
+        Returns:
+            A success message with the file content formatted as markdown
+
+        Raises:
+            FileExistsError: If the file already exists
+            ValueError: If the parent directory doesn't exist
+            PermissionError: If the file cannot be created
+            Exception: If there is a general error creating the file
+        """
+        try:
+            # Enforce vibe policy for blacklisted basenames
+            blocked_msg = self._enforce_vibe_edit_policy(relative_path)
+            if blocked_msg:
+                return blocked_msg
+
+            # Check if file already exists
+            if self.filesystem.exists(relative_path):
+                error_msg = f"File already exists: {relative_path}"
+                await self.log_error(error_msg, sender=self.caller.agent_name)
+                return error_msg
+
+            # Create parent directory if it doesn't exist
+            parent_dir = self.filesystem.get_parent(relative_path)
+            if parent_dir and parent_dir != "." and not self.filesystem.exists(parent_dir):
+                self.filesystem.create_directory(parent_dir)
+
+            # Create the file
+            self.filesystem.write_text(relative_path, content)
+
+            # Return success message with content
+            return f"File created successfully\n\n```\n{content}\n```"
+
+        except PermissionError:
+            error_msg = f"Permission denied: Cannot create file {relative_path}"
+            await self.log_error(error_msg, sender=self.caller.agent_name)
+            return error_msg
+        except Exception as e:
+            error_msg = "Error creating file"
+            await self.log_error(error_msg, sender=self.caller.agent_name)
+            return error_msg