kolega-code 0.1.0__py3-none-any.whl

kolega_code/agent/tool_backend/glob_tool.py

@@ -0,0 +1,323 @@
+from datetime import datetime
+from pathlib import Path
+from typing import List, Tuple, Literal
+import shlex
+
+from .base_tool import BaseTool
+
+FileType = Literal["f", "d"]
+FileRow = Tuple[str, FileType, int, int]  # (path, type, size_bytes, mtime_epoch)
+
+
+class GlobTool(BaseTool):
+    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",
+        ".wasm",
+        ".node",
+    }
+
+    EXCLUDE_DIRS = {
+        ".git",
+        ".svn",
+        ".hg",
+        ".idea",
+        ".vscode",
+        "__pycache__",
+        "node_modules",
+        "venv",
+        "env",
+        ".env",
+        "dist",
+        "build",
+        "target",
+        "bin",
+        "obj",
+        ".next",
+        ".nuxt",
+        "coverage",
+    }
+
+    MAX_RESULTS = 128
+    MAX_FILE_SIZE_BYTES = 10 * 1024 * 1024
+
+    async def find_files_by_pattern(
+        self, pattern: str, include_directories: bool = True, show_details: bool = True
+    ) -> str:
+        """
+        Find files matching a glob pattern in the project directory.
+
+        Args:
+            pattern: Glob pattern to match files (e.g., "*.py", "src/**/*.js")
+            include_directories: Whether to include directories in results (default: False)
+            show_details: Whether to show file details like size and modification time (default: True)
+
+        Returns:
+            Markdown formatted list of files matching the pattern, limited to MAX_RESULTS
+
+        Raises:
+            Exception: If any error occurs during the search operation
+        """
+        try:
+            await self.log_info(f"Searching for files matching pattern: '{pattern}'", sender=self.caller.agent_name)
+
+            normalized_pattern = self._normalize_pattern(pattern)
+
+            if hasattr(self.filesystem, "sandbox"):
+                rows, total_items, reached_limit = await self._search_files_sandbox(
+                    normalized_pattern, include_directories, self.MAX_RESULTS
+                )
+            else:
+                rows, total_items, reached_limit = await self._search_files_local(
+                    normalized_pattern, include_directories, self.MAX_RESULTS
+                )
+
+            if total_items == 0:
+                return f"No files found matching pattern: '{normalized_pattern}'"
+
+            return self._format_results(rows, total_items, reached_limit, show_details, normalized_pattern)
+
+        except Exception as e:
+            error_msg = f"Error finding files: {str(e)}"
+            await self.log_error(error_msg, sender=self.caller.agent_name)
+            return f"Error: {error_msg}"
+
+    def _normalize_pattern(self, pattern: str) -> str:
+        p = (pattern or "").strip()
+        if p.startswith("/"):
+            p = p[1:]
+        # Bare filename → recursive filename search
+        if all(ch not in p for ch in ("*", "?", "[")) and "/" not in p:
+            p = f"**/{p}"
+        return p
+
+    async def _search_files_local(
+        self, pattern: str, include_directories: bool, limit: int
+    ) -> Tuple[List[FileRow], int, bool]:
+        matched_paths = self.filesystem.glob(pattern)
+
+        filtered: List[FileRow] = []
+        total_items = 0
+
+        for rel_path in sorted(matched_paths):
+            is_file = self.filesystem.is_file(rel_path)
+            is_dir = self.filesystem.is_directory(rel_path)
+
+            if not include_directories and not is_file:
+                continue
+
+            # Exclude by directory names
+            parts = Path(rel_path).parts
+            if any(part in self.EXCLUDE_DIRS for part in parts):
+                continue
+
+            if is_file:
+                # Exclude by extension
+                if Path(rel_path).suffix.lower() in self.BINARY_EXTENSIONS:
+                    continue
+
+                # Exclude by size and collect size/mtime
+                try:
+                    stat_info = self.filesystem.stat(rel_path)
+                    size = int(stat_info.get("size", 0))
+                    if size > self.MAX_FILE_SIZE_BYTES:
+                        continue
+                    mtime = int(stat_info.get("modified_time", 0))
+                except Exception:
+                    # If stat fails, skip file
+                    continue
+
+                row: FileRow = (rel_path, "f", size, mtime)
+            elif is_dir and include_directories:
+                try:
+                    stat_info = self.filesystem.stat(rel_path)
+                    mtime = int(stat_info.get("modified_time", 0))
+                except Exception:
+                    mtime = 0
+                row = (rel_path, "d", 0, mtime)
+            else:
+                continue
+
+            total_items += 1
+            if len(filtered) < limit:
+                filtered.append(row)
+
+        reached_limit = total_items > limit
+        return filtered, total_items, reached_limit
+
+    async def _search_files_sandbox(
+        self, pattern: str, include_directories: bool, limit: int
+    ) -> Tuple[List[FileRow], int, bool]:
+        root = shlex.quote(getattr(self.filesystem, "root_path", "."))
+        include_flag = "1" if include_directories else "0"
+
+        # Build prune expression for find
+        exclude_list = " -o ".join([f"-name {shlex.quote(d)}" for d in sorted(self.EXCLUDE_DIRS)])
+        prune = f"\\( {exclude_list} \\) -type d -prune -o"
+
+        script = f"""bash -O globstar -c '
+set -euo pipefail
+cd {root}
+
+pattern={shlex.quote(pattern)}
+max_results={limit}
+include_dirs={include_flag}
+
+run_find() {{
+  case "$pattern" in
+    **"**/"**)
+      name_pat="${{pattern##*/}}"
+      find . {prune} -name "$name_pat" -print
+      ;;
+    *"/"*)
+      dir_part="${{pattern%/*}}"
+      name_pat="${{pattern##*/}}"
+      base_dir="${{dir_part##*/}}"
+      case " {' '.join(sorted(self.EXCLUDE_DIRS))} " in *" $base_dir "*) exit 0;; esac
+      find "$dir_part" -maxdepth 1 -name "$name_pat" -print
+      ;;
+    *)
+      find . {prune} -name "$pattern" -print
+      ;;
+  esac
+}}
+
+matches=$(run_find | sed "s#^\\./##" | sort)
+total_items=$(printf "%s\\n" "$matches" | sed "/^$/d" | wc -l | tr -d " ")
+limited=$(printf "%s\\n" "$matches" | sed "/^$/d" | head -n "$max_results")
+
+# Emit TSV: path \t type(f|d) \t size(bytes) \t mtime(epoch)
+while IFS= read -r p; do
+  [[ -z "$p" ]] && continue
+  if [[ -f "$p" ]]; then
+    sz=$(stat -c %s "$p" 2>/dev/null || echo 0)
+    mt=$(stat -c %Y "$p" 2>/dev/null || echo 0)
+    printf "%s\tf\t%s\t%s\n" "$p" "$sz" "$mt"
+  elif [[ -d "$p" ]] && [[ "$include_dirs" == "1" ]]; then
+    mt=$(stat -c %Y "$p" 2>/dev/null || echo 0)
+    printf "%s\td\t0\t%s\n" "$p" "$mt"
+  fi
+done <<< "$limited"
+
+echo "__TOTAL__ $total_items"
+'"""
+
+        result = await self.filesystem.sandbox.commands.run(script)
+        if result.exit_code != 0:
+            return [], 0, False
+
+        lines = [ln for ln in (result.stdout or "").splitlines() if ln.strip()]
+        rows: List[FileRow] = []
+        total_items = 0
+
+        for ln in lines:
+            if ln.startswith("__TOTAL__ "):
+                try:
+                    total_items = int(ln.split()[-1])
+                except Exception:
+                    total_items = len(rows)
+                continue
+            parts = ln.split("\t")
+            if len(parts) != 4:
+                continue
+            path_str, type_str, size_str, mtime_str = parts
+            # Additional filtering matching local rules
+            if type_str == "f":
+                if Path(path_str).suffix.lower() in self.BINARY_EXTENSIONS:
+                    continue
+                try:
+                    size_val = int(size_str or "0")
+                    if size_val > self.MAX_FILE_SIZE_BYTES:
+                        continue
+                except Exception:
+                    continue
+            rows.append((path_str, "f" if type_str == "f" else "d", int(size_str or "0"), int(float(mtime_str or "0"))))
+
+        reached_limit = total_items > limit
+        return rows, total_items, reached_limit
+
+    def _format_results(
+        self, rows: List[FileRow], total_items: int, reached_limit: bool, show_details: bool, pattern: str
+    ) -> str:
+        results: List[str] = [f"# Files Matching '{pattern}'"]
+        if reached_limit:
+            results.append(f"\nFound {total_items} matching items (showing first {self.MAX_RESULTS})\n")
+            results.append(f"⚠️ **Note:** Displaying only the first {self.MAX_RESULTS} of {total_items} results.\n")
+        else:
+            results.append(f"\nFound {total_items} matching items\n")
+
+        by_directory: dict[str, List[FileRow]] = {}
+        for path_str, ftype, size_bytes, mtime_epoch in rows:
+            parent = self.filesystem.get_parent(path_str) or ""
+            by_directory.setdefault(parent, []).append((path_str, ftype, size_bytes, mtime_epoch))
+
+        for directory in sorted(by_directory.keys()):
+            # Match original behavior: only empty string maps to Root Directory; '.' prints as './'
+            if directory:
+                results.append(f"## {directory}/")
+            else:
+                results.append("## Root Directory")
+
+            for path_str, ftype, size_bytes, mtime_epoch in sorted(by_directory[directory]):
+                filename = self.filesystem.get_name(path_str)
+                if ftype == "d":
+                    item_type = "📁 Directory"
+                    size_text = "unknown items"
+                else:
+                    item_type = "📄 File"
+                    try:
+                        if size_bytes < 1024:
+                            size_text = f"{size_bytes} bytes"
+                        elif size_bytes < 1024 * 1024:
+                            size_text = f"{size_bytes/1024:.1f} KB"
+                        else:
+                            size_text = f"{size_bytes/(1024*1024):.1f} MB"
+                    except Exception:
+                        size_text = "unknown size"
+
+                line = f"- **{filename}** ({item_type})"
+                if show_details:
+                    try:
+                        mod_time = datetime.fromtimestamp(mtime_epoch)
+                        mod_time_str = mod_time.strftime("%Y-%m-%d %H:%M:%S")
+                        line += f"\n  - Size: {size_text}"
+                        line += f"\n  - Modified: {mod_time_str}"
+                        if ftype == "f":
+                            ext = Path(filename).suffix
+                            if ext:
+                                line += f"\n  - Type: {ext} file"
+                    except Exception:
+                        line += f"\n  - Size: {size_text}"
+                results.append(line)
+            results.append("")
+
+        return "\n".join(results)

kolega_code/agent/tool_backend/list_directory_tool.py

@@ -0,0 +1,300 @@
+from datetime import datetime
+from pathlib import Path
+
+from .base_tool import BaseTool
+
+
+class ListDirectoryTool(BaseTool):
+    async def list_directory(self, relative_path: str = "") -> str:
+        """
+        List files and directories at the specified path.
+
+        Args:
+            relative_path: Path to list, relative to the project root
+
+        Returns:
+            Markdown formatted list of files and directories with details
+
+        Raises:
+            NotADirectoryError: If the path is not a directory
+        """
+        if not self.filesystem.exists(relative_path):
+            raise FileNotFoundError(f"Directory not found: {relative_path}")
+
+        if not self.filesystem.is_directory(relative_path):
+            raise NotADirectoryError(f"Not a directory: {relative_path}")
+
+        # Use sandbox-specific implementation if available
+        if hasattr(self.filesystem, "sandbox"):
+            return await self._list_directory_sandbox(relative_path)
+        else:
+            # Use the original implementation for local filesystem
+            return await self._list_directory_local(relative_path)
+
+    async def _list_directory_sandbox(self, relative_path: str) -> str:
+        """
+        Sandbox-specific implementation using a single command for efficiency.
+        """
+        # Resolve the full path
+        full_path = self.filesystem._resolve_path(relative_path) if relative_path else self.filesystem.root_path
+
+        # Use ls with detailed format to get all info in one command
+        # -la: list all files with details
+        # --time-style=long-iso: consistent datetime format
+        # --group-directories-first: directories first
+        ls_cmd = f"cd {full_path} && ls -la --time-style=long-iso --group-directories-first 2>/dev/null"
+
+        # Also get directory item counts in one go
+        # Use a more robust command that handles cases with no directories
+        count_cmd = f'cd {full_path} && find . -maxdepth 1 -type d ! -name . -exec sh -c \'echo "$(basename "{{}}"):$(ls -1 "{{}}" 2>/dev/null | wc -l)"\' \\; 2>/dev/null || true'
+
+        # Run both commands - always await since sandbox commands are always async
+        ls_result = await self.filesystem.sandbox.commands.run(ls_cmd)
+        count_result = await self.filesystem.sandbox.commands.run(count_cmd)
+
+        if ls_result.exit_code != 0:
+            raise OSError(f"Failed to list directory: {ls_result.stderr}")
+
+        # Parse directory counts
+        dir_counts = {}
+        if count_result.exit_code == 0 and count_result.stdout.strip():
+            for line in count_result.stdout.strip().split("\n"):
+                if ":" in line:
+                    dir_name, count = line.rsplit(":", 1)
+                    dir_counts[dir_name.rstrip("/")] = count.strip()
+
+        # Parse ls output
+        lines_data = []
+        for line in ls_result.stdout.strip().split("\n")[1:]:  # Skip "total" line
+            parts = line.split(None, 8)  # Split into max 9 parts
+            if len(parts) < 8:  # With long-iso format, we need at least 8 parts
+                continue
+
+            permissions = parts[0]
+            # parts[1] = number of links (skip)
+            # parts[2] = owner (skip)
+            # parts[3] = group (skip)
+            size = parts[4]
+            date = parts[5]  # Date in YYYY-MM-DD format
+            time = parts[6]  # Time in HH:MM format
+            name = parts[7] if len(parts) == 8 else " ".join(parts[7:])  # Handle filenames with spaces
+
+            # Skip . and ..
+            if name in [".", ".."]:
+                continue
+
+            # Skip .git directory
+            if name == ".git":
+                continue
+
+            # Determine if it's a directory
+            is_dir = permissions.startswith("d")
+
+            # Clean up name (remove trailing / for directories)
+            clean_name = name.rstrip("/")
+
+            # Build relative path
+            if relative_path:
+                item_path = f"{relative_path}/{clean_name}"
+            else:
+                item_path = clean_name
+
+            lines_data.append(
+                {
+                    "name": clean_name,
+                    "path": item_path,
+                    "is_dir": is_dir,
+                    "size": int(size) if not is_dir else dir_counts.get(clean_name, "0"),
+                    "date": f"{date} {time}",
+                    "permissions": permissions,
+                }
+            )
+
+        # Sort: directories first, then alphabetically
+        lines_data.sort(key=lambda x: (not x["is_dir"], x["name"].lower()))
+
+        # Build the markdown output
+        return self._format_directory_listing(relative_path, lines_data)
+
+    async def _list_directory_local(self, relative_path: str) -> str:
+        """
+        Original implementation for local filesystem.
+        """
+        # Get all items in the directory
+        items = self.filesystem.list_directory(relative_path)
+
+        # Sort items: directories first, then files, alphabetically within each group
+        items.sort(key=lambda x: (not self.filesystem.is_directory(x), self.filesystem.get_name(x).lower()))
+
+        # Build data for formatting
+        lines_data = []
+        for item in items:
+            # Skip .git directory
+            if self.filesystem.get_name(item) == ".git":
+                continue
+
+            try:
+                is_dir = self.filesystem.is_directory(item)
+
+                if is_dir:
+                    # For directories, count items
+                    try:
+                        dir_items = self.filesystem.list_directory(item)
+                        size = len(dir_items)
+                    except:
+                        size = 0
+                else:
+                    # For files, get size
+                    try:
+                        size = self.filesystem.get_size(item)
+                    except:
+                        size = 0
+
+                # Get modification time
+                try:
+                    mod_time = self.filesystem.get_modification_time(item).strftime("%Y-%m-%d %H:%M")
+                except:
+                    mod_time = "Unknown"
+
+                lines_data.append(
+                    {
+                        "name": self.filesystem.get_name(item),
+                        "path": item,
+                        "is_dir": is_dir,
+                        "size": size,
+                        "date": mod_time,
+                        "permissions": None,  # Not available in local
+                    }
+                )
+            except Exception as e:
+                # Log error but continue
+                await self.log_error(f"Error processing item {item}: {e}", sender=self.caller.agent_name)
+                continue
+
+        return self._format_directory_listing(relative_path, lines_data)
+
+    def _format_directory_listing(self, relative_path: str, items_data: list) -> str:
+        """
+        Format the directory listing data into markdown.
+        """
+        # Prepare the header
+        if relative_path:
+            title = f"# Directory: {relative_path}"
+            parent_dir = str(Path(relative_path).parent)
+            if parent_dir and parent_dir != ".":
+                navigation = f"📁 Parent Directory: {parent_dir}"
+            else:
+                navigation = f"📁 Root Directory"
+        else:
+            title = "# Root Directory"
+            navigation = ""
+
+        lines = [title, ""]
+        if navigation:
+            lines.append(navigation)
+            lines.append("")
+
+        lines.append("| Type | Name | Size | Modified | Description |")
+        lines.append("|------|------|------|----------|-------------|")
+
+        # Process each item
+        total_size = 0
+        dir_count = 0
+        file_count = 0
+
+        for item_data in items_data:
+            name = item_data["name"]
+            path = item_data["path"]
+            is_dir = item_data["is_dir"]
+            size = item_data["size"]
+            date = item_data["date"]
+
+            if is_dir:
+                icon = "📁"
+                size_str = f"{size} items"
+                description = "Directory"
+                dir_count += 1
+            else:
+                icon = "📄"
+                size_str = self._format_size(size)
+                description = self._get_file_description(name)
+                file_count += 1
+                total_size += size
+
+            # Clean up and escape the name
+            escaped_name = name.replace("|", "\\|")
+
+            # Format the line
+            lines.append(f"| {icon} | {escaped_name} | {size_str} | {date} | {description} |")
+
+        # Add summary
+        lines.append("")
+        lines.append(f"**Summary:** {dir_count} directories, {file_count} files, {self._format_size(total_size)} total")
+
+        return "\n".join(lines)
+
+    def _format_size(self, size_bytes: int) -> str:
+        """Format file size in human-readable format."""
+        if size_bytes < 1024:
+            return f"{size_bytes} B"
+        elif size_bytes < 1024 * 1024:
+            return f"{size_bytes/1024:.1f} KB"
+        elif size_bytes < 1024 * 1024 * 1024:
+            return f"{size_bytes/(1024*1024):.1f} MB"
+        else:
+            return f"{size_bytes/(1024*1024*1024):.1f} GB"
+
+    def _get_file_description(self, filename: str) -> str:
+        """Get a description based on file extension."""
+        extension_map = {
+            ".py": "Python Source",
+            ".js": "JavaScript Source",
+            ".jsx": "React JSX Source",
+            ".ts": "TypeScript Source",
+            ".tsx": "React TSX Source",
+            ".html": "HTML Document",
+            ".css": "CSS Stylesheet",
+            ".json": "JSON Data",
+            ".md": "Markdown Document",
+            ".txt": "Text File",
+            ".csv": "CSV Data",
+            ".yml": "YAML Configuration",
+            ".yaml": "YAML Configuration",
+            ".xml": "XML Document",
+            ".sql": "SQL Script",
+            ".sh": "Shell Script",
+            ".bat": "Batch Script",
+            ".ps1": "PowerShell Script",
+            ".jpg": "JPEG Image",
+            ".jpeg": "JPEG Image",
+            ".png": "PNG Image",
+            ".gif": "GIF Image",
+            ".svg": "SVG Image",
+            ".pdf": "PDF Document",
+            ".zip": "ZIP Archive",
+            ".tar": "TAR Archive",
+            ".gz": "GZIP Archive",
+            ".env": "Environment Variables",
+            ".dockerfile": "Docker Definition",
+        }
+
+        # Handle special files by exact filename match
+        lower_name = filename.lower()
+        if lower_name == "dockerfile":
+            return "Docker Definition"
+        elif lower_name == ".gitignore":
+            return "Git Ignore Rules"
+        elif lower_name == "readme.md":
+            return "Project Documentation"
+        elif lower_name == "license":
+            return "License Information"
+        elif lower_name == "requirements.txt":
+            return "Python Dependencies"
+        elif lower_name == "package.json":
+            return "Node.js Package"
+        elif lower_name in ["makefile", "makefile.in"]:
+            return "Make Build Rules"
+
+        # Get extension
+        ext = Path(filename).suffix.lower()
+        return extension_map.get(ext, f"{ext[1:].upper() if ext else 'Unknown'} File")