portacode 1.3.34__py3-none-any.whl → 1.3.36__py3-none-any.whl

portacode/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '1.3.34'
-__version_tuple__ = version_tuple = (1, 3, 34)
+__version__ = version = '1.3.36'
+__version_tuple__ = version_tuple = (1, 3, 36)
 
 __commit_id__ = commit_id = None

portacode/connection/handlers/WEBSOCKET_PROTOCOL.md

@@ -43,6 +43,7 @@ This document describes the complete protocol for communicating with devices thr
     - [`system_info`](#system_info)
   - [File Actions](#file-actions)
     - [`file_read`](#file_read)
+    - [`file_search`](#file_search)
     - [`file_write`](#file_write)
     - [`directory_list`](#directory_list)
     - [`file_info`](#file_info)
@@ -80,6 +81,7 @@ This document describes the complete protocol for communicating with devices thr
     - [`system_info`](#system_info-event)
   - [File Events](#file-events)
     - [`file_read_response`](#file_read_response)
+    - [`file_search_response`](#file_search_response)
     - [`file_write_response`](#file_write_response)
     - [`directory_list_response`](#directory_list_response)
     - [`file_info_response`](#file_info_response)
@@ -317,12 +319,46 @@ Reads the content of a file. Handled by [`file_read`](./file_handlers.py).
 **Payload Fields:**
 
 *   `path` (string, mandatory): The absolute path to the file to read.
+*   `start_line` (integer, optional): 1-based line number to start reading from. Defaults to `1`.
+*   `end_line` (integer, optional): 1-based line number to stop reading at (inclusive). When provided, limits the response to the range between `start_line` and `end_line`.
+*   `max_lines` (integer, optional): Maximum number of lines to return (capped at 2000). Useful for pagination when `end_line` is not specified.
+*   `encoding` (string, optional): Text encoding to use when reading the file. Defaults to `utf-8` with replacement for invalid bytes.
 
 **Responses:**
 
 *   On success, the device will respond with a [`file_read_response`](#file_read_response) event.
 *   On error, a generic [`error`](#error) event is sent.
 
+### `file_search`
+
+Searches for text matches within files beneath a given root directory. Handled by [`file_search`](./file_handlers.py).
+
+**Payload Fields:**
+
+*   `root_path` (string, mandatory): The absolute path that acts as the search root (typically a project folder).
+*   `query` (string, mandatory): The search query. Treated as plain text unless `regex=true`.
+*   `match_case` (boolean, optional): When `true`, performs a case-sensitive search. Defaults to `false`.
+*   `regex` (boolean, optional): When `true`, interprets `query` as a regular expression. Defaults to `false`.
+*   `whole_word` (boolean, optional): When `true`, matches only whole words. Works with both plain text and regex queries.
+*   `include_patterns` (array[string], optional): Glob patterns that files must match to be included (e.g., `["src/**/*.py"]`).
+*   `exclude_patterns` (array[string], optional): Glob patterns for files/directories to skip (e.g., `["**/tests/**"]`).
+*   `include_hidden` (boolean, optional): When `true`, includes hidden files and folders. Defaults to `false`.
+*   `max_results` (integer, optional): Maximum number of match entries to return (capped at 500). Defaults to `40`.
+*   `max_matches_per_file` (integer, optional): Maximum number of matches to return per file (capped at 50). Defaults to `5`.
+*   `max_file_size` (integer, optional): Maximum file size in bytes to scan (defaults to 1 MiB).
+*   `max_line_length` (integer, optional): Maximum number of characters to return per matching line (defaults to `200`).
+
+**Default Behaviour:**
+
+* Binary files and large vendor/static directories (e.g., `node_modules`, `dist`, `static`) are skipped automatically unless custom `exclude_patterns` are provided.
+* Only common source/text extensions are scanned by default (override with `include_patterns` to widen the scope).
+* Searches stop after 10 seconds, respecting both per-file and global match limits to avoid oversized responses.
+
+**Responses:**
+
+*   On success, the device will respond with a [`file_search_response`](#file_search_response) event containing the matches.
+*   On error, a generic [`error`](#error) event is sent.
+
 ### `file_write`
 
 Writes content to a file. Handled by [`file_write`](./file_handlers.py).
@@ -345,6 +381,8 @@ Lists the contents of a directory. Handled by [`directory_list`](./file_handlers
 
 *   `path` (string, optional): The path to the directory to list. Defaults to the current directory.
 *   `show_hidden` (boolean, optional): Whether to include hidden files in the listing. Defaults to `false`.
+*   `limit` (integer, optional): Maximum number of entries to return (defaults to “all”). Values above 1000 are clamped to 1000.
+*   `offset` (integer, optional): Number of entries to skip before collecting results (defaults to `0`).
 
 **Responses:**
 
@@ -814,8 +852,39 @@ Returns the content of a file in response to a `file_read` action. Handled by [`
 **Event Fields:**
 
 *   `path` (string, mandatory): The path of the file that was read.
-*   `content` (string, mandatory): The content of the file.
-*   `size` (integer, mandatory): The size of the file in bytes.
+*   `content` (string, mandatory): The file content returned (may be a slice when pagination parameters are used).
+*   `size` (integer, mandatory): The total size of the file in bytes.
+*   `total_lines` (integer, optional): Total number of lines detected in the file.
+*   `returned_lines` (integer, optional): Number of lines included in `content`.
+*   `start_line` (integer, optional): The first line number included in the response (if any lines were returned).
+*   `requested_start_line` (integer, optional): The requested starting line supplied in the command.
+*   `end_line` (integer, optional): The last line number included in the response.
+*   `has_more_before` (boolean, optional): Whether there is additional content before the returned range.
+*   `has_more_after` (boolean, optional): Whether there is additional content after the returned range.
+*   `encoding` (string, optional): Encoding that was used while reading the file.
+
+### <a name="file_search_response"></a>`file_search_response`
+
+Returns aggregated search results in response to a `file_search` action. Handled by [`file_search`](./file_handlers.py).
+
+**Event Fields:**
+
+*   `root_path` (string, mandatory): The root directory that was searched.
+*   `query` (string, mandatory): The query string that was used.
+*   `match_case` (boolean, mandatory): Indicates if the search was case sensitive.
+*   `regex` (boolean, mandatory): Indicates if the query was interpreted as a regular expression.
+*   `whole_word` (boolean, mandatory): Indicates if the search matched whole words only.
+*   `include_patterns` (array[string], mandatory): Effective include glob patterns.
+*   `exclude_patterns` (array[string], mandatory): Effective exclude glob patterns.
+*   `matches` (array, mandatory): List of match objects containing `relative_path`, `path`, `line_number`, `line`, `match_spans` `[start, end]`, `match_count`, and `line_truncated` (boolean).
+*   `matches_returned` (integer, mandatory): Number of match entries returned (length of `matches`).
+*   `total_matches` (integer, mandatory): Total number of matches found while scanning.
+*   `files_scanned` (integer, mandatory): Count of files inspected.
+*   `truncated` (boolean, mandatory): Indicates if additional matches exist beyond those returned.
+*   `truncated_count` (integer, optional): Number of matches that were omitted due to truncation limits.
+*   `max_results` (integer, mandatory): Maximum number of matches requested.
+*   `max_matches_per_file` (integer, mandatory): Maximum matches requested per file.
+*   `errors` (array[string], optional): Non-fatal errors encountered during scanning (e.g., unreadable files).
 
 ### <a name="file_write_response"></a>`file_write_response`
 
@@ -835,7 +904,11 @@ Returns the contents of a directory in response to a `directory_list` action. Ha
 
 *   `path` (string, mandatory): The path of the directory that was listed.
 *   `items` (array, mandatory): A list of objects, each representing a file or directory in the listed directory.
-*   `count` (integer, mandatory): The number of items in the `items` list.
+*   `count` (integer, mandatory): The number of items returned in this response (honours `limit`/`offset`).
+*   `total_count` (integer, mandatory): Total number of entries in the directory before pagination.
+*   `offset` (integer, optional): Offset that was applied.
+*   `limit` (integer, optional): Limit that was applied (or `null` if none).
+*   `has_more` (boolean, optional): Indicates whether additional items remain beyond the returned slice.
 
 ### <a name="file_info_response"></a>`file_info_response`
 
@@ -1277,4 +1350,4 @@ Sent by the server to clients to provide initial device list snapshot.
 
 **Event Fields:**
 
-*   `devices` (array, mandatory): Array of device objects with status information
+*   `devices` (array, mandatory): Array of device objects with status information

portacode/connection/handlers/__init__.py

@@ -23,6 +23,7 @@ from .file_handlers import (
     FileCreateHandler,
     FolderCreateHandler,
     FileRenameHandler,
+    FileSearchHandler,
     ContentRequestHandler,
 )
 from .project_state_handlers import (
@@ -58,6 +59,7 @@ __all__ = [
     "FileCreateHandler",
     "FolderCreateHandler",
     "FileRenameHandler",
+    "FileSearchHandler",
     "ContentRequestHandler",
     # Project state handlers
     "ProjectStateFolderExpandHandler",
@@ -71,4 +73,4 @@ __all__ = [
     "ProjectStateGitUnstageHandler",
     "ProjectStateGitRevertHandler",
     "ProjectStateGitCommitHandler",
-] 
+] 

portacode/connection/handlers/file_handlers.py

@@ -2,7 +2,13 @@
 
 import os
 import logging
-from typing import Any, Dict, List
+import fnmatch
+import re
+import json
+import shutil
+import subprocess
+import time
+from typing import Any, Dict, List, Optional, Sequence
 from pathlib import Path
 
 from .base import AsyncHandler, SyncHandler
@@ -22,27 +28,101 @@ class FileReadHandler(SyncHandler):
         return "file_read"
     
     def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
-        """Read file contents."""
+        """Read file contents with optional pagination."""
         file_path = message.get("path")
         if not file_path:
             raise ValueError("path parameter is required")
-        
+
+        encoding = message.get("encoding", "utf-8")
+        start_line = self._coerce_positive_int(message.get("start_line"), default=1)
+        max_lines = self._coerce_positive_int(message.get("max_lines"), allow_none=True)
+        end_line = self._coerce_positive_int(message.get("end_line"), allow_none=True)
+
+        if start_line < 1:
+            start_line = 1
+
+        if end_line is not None and end_line >= start_line:
+            range_len = end_line - start_line + 1
+            if max_lines is None:
+                max_lines = range_len
+            else:
+                max_lines = min(max_lines, range_len)
+
+        if max_lines is not None:
+            max_lines = min(max_lines, 2000)
+
         try:
-            with open(file_path, 'r', encoding='utf-8') as f:
-                content = f.read()
-            
-            return {
-                "event": "file_read_response",
-                "path": file_path,
-                "content": content,
-                "size": len(content),
-            }
+            file_size = os.path.getsize(file_path)
+        except FileNotFoundError:
+            raise ValueError(f"File not found: {file_path}")
+        except PermissionError:
+            raise RuntimeError(f"Permission denied: {file_path}")
+
+        total_lines = 0
+        collected_lines: List[str] = []
+        truncated_after = False
+
+        try:
+            with open(file_path, "r", encoding=encoding, errors="replace") as file_obj:
+                for idx, line in enumerate(file_obj, start=1):
+                    total_lines += 1
+                    if idx < start_line:
+                        continue
+
+                    if max_lines is not None and len(collected_lines) >= max_lines:
+                        truncated_after = True
+                        continue
+
+                    collected_lines.append(line)
         except FileNotFoundError:
             raise ValueError(f"File not found: {file_path}")
         except PermissionError:
             raise RuntimeError(f"Permission denied: {file_path}")
-        except UnicodeDecodeError:
-            raise RuntimeError(f"File is not text or uses unsupported encoding: {file_path}")
+        except OSError as exc:
+            raise RuntimeError(f"Error reading file: {exc}")
+
+        returned_start_line = start_line if collected_lines else None
+        returned_end_line = (
+            start_line + len(collected_lines) - 1 if collected_lines else None
+        )
+        has_more_before = bool(collected_lines) and start_line > 1
+        has_more_after = truncated_after or (
+            returned_end_line is not None and total_lines > returned_end_line
+        )
+
+        return {
+            "event": "file_read_response",
+            "path": file_path,
+            "content": "".join(collected_lines),
+            "size": file_size,
+            "total_lines": total_lines,
+            "returned_lines": len(collected_lines),
+            "start_line": returned_start_line,
+            "requested_start_line": start_line,
+            "end_line": returned_end_line,
+            "has_more_before": has_more_before,
+            "has_more_after": has_more_after,
+            "encoding": encoding,
+        }
+
+    @staticmethod
+    def _coerce_positive_int(
+        value: Any,
+        *,
+        default: Optional[int] = None,
+        allow_none: bool = False,
+    ) -> Optional[int]:
+        if value is None:
+            if allow_none:
+                return None
+            return default or 0
+        try:
+            coerced = int(value)
+        except (TypeError, ValueError):
+            return None if allow_none else (default or 0)
+        if coerced <= 0:
+            return None if allow_none else (default or 0)
+        return coerced
 
 
 class FileWriteHandler(SyncHandler):
@@ -90,6 +170,24 @@ class DirectoryListHandler(SyncHandler):
         """List directory contents."""
         path = message.get("path", ".")
         show_hidden = message.get("show_hidden", False)
+        limit_raw = message.get("limit")
+        offset_raw = message.get("offset", 0)
+
+        def _parse_positive_int(value, *, allow_none=False, minimum=0, maximum=None):
+            if value is None:
+                return None if allow_none else minimum
+            try:
+                parsed = int(value)
+            except (TypeError, ValueError):
+                return None if allow_none else minimum
+            if parsed < minimum:
+                parsed = minimum
+            if maximum is not None and parsed > maximum:
+                parsed = maximum
+            return parsed
+
+        offset = _parse_positive_int(offset_raw, minimum=0)
+        limit = _parse_positive_int(limit_raw, allow_none=True, minimum=1, maximum=1000)
         
         try:
             items = []
@@ -113,11 +211,31 @@ class DirectoryListHandler(SyncHandler):
                     # Skip items we can't stat
                     continue
             
+            total_count = len(items)
+
+            if offset:
+                if offset >= total_count:
+                    sliced_items = []
+                else:
+                    sliced_items = items[offset:]
+            else:
+                sliced_items = items
+
+            if limit is not None and limit >= 0:
+                sliced_items = sliced_items[:limit]
+
+            returned_count = len(sliced_items)
+            has_more = total_count > offset + returned_count if total_count else False
+            
             return {
                 "event": "directory_list_response",
                 "path": path,
-                "items": items,
-                "count": len(items),
+                "items": sliced_items,
+                "count": returned_count,
+                "total_count": total_count,
+                "offset": offset,
+                "limit": limit,
+                "has_more": has_more,
             }
         except FileNotFoundError:
             raise ValueError(f"Directory not found: {path}")
@@ -372,6 +490,545 @@ class FileRenameHandler(SyncHandler):
             raise RuntimeError(f"Failed to rename: {e}")
 
 
+class FileSearchHandler(SyncHandler):
+    """Handler for searching text within files under a root directory."""
+
+    DEFAULT_EXCLUDE_DIRS: Sequence[str] = (
+        ".git",
+        ".hg",
+        ".svn",
+        "__pycache__",
+        "node_modules",
+        "vendor",
+        "dist",
+        "build",
+        "tmp",
+        "static",
+        "assets",
+        "coverage",
+    )
+
+    DEFAULT_EXCLUDE_FILE_GLOBS: Sequence[str] = (
+        "*.min.js",
+        "*.min.css",
+    )
+
+    BINARY_EXTENSIONS: Sequence[str] = (
+        ".png", ".jpg", ".jpeg", ".gif", ".bmp", ".svg", ".ico",
+        ".pdf", ".zip", ".tar", ".gz", ".bz2", ".xz", ".7z",
+        ".ttf", ".woff", ".woff2", ".eot",
+        ".mp3", ".mp4", ".mov", ".avi", ".wav", ".flac",
+        ".exe", ".dll", ".so", ".dylib",
+        ".class", ".jar",
+    )
+
+    DEFAULT_INCLUDE_EXTENSIONS: Sequence[str] = (
+        ".py", ".pyi", ".pyx",
+        ".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs",
+        ".json", ".yaml", ".yml", ".toml", ".ini", ".cfg", ".conf",
+        ".md", ".markdown", ".rst", ".txt",
+        ".html", ".htm", ".css", ".scss", ".less",
+        ".go", ".rs", ".java", ".kt", ".kts",
+        ".c", ".h", ".hpp", ".hh", ".cc", ".cpp", ".cxx",
+        ".cs", ".php", ".rb", ".swift", ".scala", ".sql",
+        ".sh", ".bash", ".zsh", ".fish",
+        ".env", ".dockerfile", ".gradle", ".mk", ".make", ".bat", ".ps1",
+    )
+
+    ALWAYS_INCLUDE_FILENAMES: Sequence[str] = (
+        "Makefile",
+        "Dockerfile",
+        "Jenkinsfile",
+        "Procfile",
+        "Gemfile",
+        "CMakeLists.txt",
+        "build.gradle",
+        "settings.gradle",
+        "package.json",
+        "pnpm-lock.yaml",
+        "yarn.lock",
+        "requirements.txt",
+        "pyproject.toml",
+    )
+
+    @property
+    def command_name(self) -> str:
+        return "file_search"
+
+    def _search_with_rg(
+        self,
+        *,
+        root_path: str,
+        query: str,
+        match_case: bool,
+        use_regex: bool,
+        whole_word: bool,
+        include_hidden: bool,
+        max_results: int,
+        max_per_file: int,
+        max_file_size: int,
+        include_patterns: List[str],
+        exclude_patterns: List[str],
+        max_line_length: int,
+        using_default_includes: bool,
+    ) -> Optional[Dict[str, Any]]:
+        """Perform fast search using ripgrep if available."""
+        if shutil.which("rg") is None:
+            return None
+
+        cmd = [
+            "rg",
+            "--json",
+            "--line-number",
+            "--color",
+            "never",
+            "--no-heading",
+            "--max-count",
+            str(max_per_file),
+            f"--max-filesize={max_file_size}B",
+        ]
+
+        if not match_case:
+            cmd.append("--ignore-case")
+        if not use_regex:
+            cmd.append("--fixed-strings")
+        if whole_word:
+            cmd.append("--word-regexp")
+        if include_hidden:
+            cmd.append("--hidden")
+
+        if using_default_includes:
+            for ext in self.DEFAULT_INCLUDE_EXTENSIONS:
+                cmd.extend(["-g", f"*{ext}"])
+            for name in self.ALWAYS_INCLUDE_FILENAMES:
+                cmd.extend(["-g", name])
+        for pattern in include_patterns:
+            cmd.extend(["-g", pattern])
+        for pattern in exclude_patterns:
+            cmd.extend(["-g", f"!{pattern}"])
+
+        cmd.append(query)
+        cmd.append(".")
+
+        matches: List[Dict[str, Any]] = []
+        truncated = False
+        truncated_count = 0
+        files_scanned = 0
+        errors: List[str] = []
+        stop_search = False
+        deadline = time.monotonic() + 10.0  # hard cap to avoid long-running scans
+
+        try:
+            proc = subprocess.Popen(
+                cmd,
+                cwd=root_path,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                text=True,
+            )
+        except Exception as exc:
+            logger.warning("Failed to execute ripgrep: %s", exc)
+            return None
+
+        try:
+            assert proc.stdout is not None
+            for line in proc.stdout:
+                line = line.strip()
+                if not line:
+                    continue
+
+                if time.monotonic() > deadline:
+                    truncated = True
+                    errors.append("Search aborted after reaching 10s execution limit.")
+                    stop_search = True
+                    break
+
+                try:
+                    payload = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+
+                event_type = payload.get("type")
+
+                if event_type == "begin":
+                    files_scanned += 1
+                    continue
+
+                if event_type == "match":
+                    data = payload.get("data", {})
+                    line_text = data.get("lines", {}).get("text", "")
+                    line_number = data.get("line_number")
+                    path_info = data.get("path", {}).get("text") or data.get("path", {}).get("bytes")
+                    if not path_info:
+                        continue
+                    absolute_path = os.path.join(root_path, path_info)
+                    relative_path = path_info
+
+                    submatches = data.get("submatches", [])
+                    if len(matches) >= max_results:
+                        truncated = True
+                        truncated_count += len(submatches)
+                        stop_search = True
+                        break
+
+                    available = max_results - len(matches)
+                    spans: List[List[int]] = []
+                    for submatch in submatches:
+                        if len(spans) >= available:
+                            truncated = True
+                            truncated_count += len(submatches) - len(spans)
+                            stop_search = True
+                            break
+                        start = submatch.get("start", {}).get("offset")
+                        end = submatch.get("end", {}).get("offset")
+                        if start is None or end is None:
+                            continue
+                        spans.append([start, end])
+
+                    if spans:
+                        clean_line = line_text.rstrip("\n")
+                        truncated_line = clean_line
+                        line_truncated = False
+                        if len(clean_line) > max_line_length:
+                            truncated_line = clean_line[:max_line_length] + "..."
+                            line_truncated = True
+
+                        matches.append(
+                            {
+                                "path": absolute_path,
+                                "relative_path": relative_path,
+                                "line_number": line_number,
+                                "line": truncated_line,
+                                "match_spans": spans,
+                                "match_count": len(spans),
+                                "line_truncated": line_truncated,
+                            }
+                        )
+
+                    if stop_search:
+                        break
+                elif event_type == "message":
+                    message = payload.get("data", {}).get("msg") or payload.get("data", {}).get("text")
+                    if message:
+                        errors.append(message)
+
+                if stop_search:
+                    break
+        finally:
+            if stop_search and proc.poll() is None:
+                try:
+                    proc.terminate()
+                    proc.wait(timeout=1.0)
+                except Exception:
+                    proc.kill()
+            else:
+                proc.wait()
+
+        stderr_output = ""
+        if proc.stderr:
+            try:
+                stderr_output = proc.stderr.read().strip()
+            except Exception:
+                stderr_output = ""
+        if stderr_output:
+            errors.append(stderr_output)
+
+        return {
+            "event": "file_search_response",
+            "root_path": root_path,
+            "query": query,
+            "match_case": match_case,
+            "regex": use_regex,
+            "whole_word": whole_word,
+            "include_patterns": include_patterns,
+            "exclude_patterns": exclude_patterns,
+            "matches": matches,
+            "matches_returned": len(matches),
+            "total_matches": len(matches) + truncated_count,
+            "files_scanned": files_scanned,
+            "truncated": truncated or truncated_count > 0,
+            "truncated_count": truncated_count,
+            "max_results": max_results,
+            "max_matches_per_file": max_per_file,
+            "errors": errors,
+        }
+
+    def execute(self, message: Dict[str, Any]) -> Dict[str, Any]:
+        root_path = message.get("root_path")
+        query = message.get("query")
+
+        if not root_path:
+            raise ValueError("root_path parameter is required")
+        if not query:
+            raise ValueError("query parameter is required")
+
+        if not os.path.isdir(root_path):
+            raise ValueError(f"Root path is not a directory: {root_path}")
+
+        match_case = bool(message.get("match_case", False))
+        use_regex = bool(message.get("regex", False))
+        whole_word = bool(message.get("whole_word", False))
+        include_hidden = bool(message.get("include_hidden", False))
+
+        max_results = self._clamp_int(message.get("max_results"), default=40, min_value=1, max_value=500)
+        max_per_file = self._clamp_int(
+            message.get("max_matches_per_file"),
+            default=5,
+            min_value=1,
+            max_value=50,
+        )
+        max_file_size = self._clamp_int(
+            message.get("max_file_size"),
+            default=1024 * 1024,
+            min_value=1024,
+            max_value=10 * 1024 * 1024,
+        )
+        max_line_length = self._clamp_int(
+            message.get("max_line_length"),
+            default=200,
+            min_value=32,
+            max_value=1024,
+        )
+
+        include_patterns = self._normalize_patterns(message.get("include_patterns"))
+        using_default_includes = not include_patterns
+        raw_exclude_patterns = self._normalize_patterns(message.get("exclude_patterns"))
+        using_default_excludes = not raw_exclude_patterns
+        if using_default_excludes:
+            exclude_patterns = []
+            for directory in self.DEFAULT_EXCLUDE_DIRS:
+                exclude_patterns.append(f"{directory}/**")
+                exclude_patterns.append(f"**/{directory}/**")
+            exclude_patterns.extend(self.DEFAULT_EXCLUDE_FILE_GLOBS)
+        else:
+            exclude_patterns = raw_exclude_patterns
+
+        flags = 0 if match_case else re.IGNORECASE
+        pattern = query if use_regex else re.escape(query)
+        if whole_word:
+            pattern = r"\b" + pattern + r"\b"
+
+        try:
+            compiled = re.compile(pattern, flags)
+        except re.error as exc:
+            raise ValueError(f"Invalid regular expression: {exc}") from exc
+
+        rg_result = self._search_with_rg(
+            root_path=root_path,
+            query=query,
+            match_case=match_case,
+            use_regex=use_regex,
+            whole_word=whole_word,
+            include_hidden=include_hidden,
+            max_results=max_results,
+            max_per_file=max_per_file,
+            max_file_size=max_file_size,
+            include_patterns=include_patterns,
+            exclude_patterns=exclude_patterns,
+            max_line_length=max_line_length,
+            using_default_includes=using_default_includes,
+        )
+        if rg_result is not None:
+            return rg_result
+
+        matches: List[Dict[str, Any]] = []
+        truncated = False
+        truncated_count = 0
+        files_scanned = 0
+        errors: List[str] = []
+        stop_search = False
+
+        binary_exts = {ext.lower() for ext in self.BINARY_EXTENSIONS}
+        allowed_exts = {ext.lower() for ext in self.DEFAULT_INCLUDE_EXTENSIONS}
+
+        deadline = time.monotonic() + 10.0
+
+        for dirpath, dirnames, filenames in os.walk(root_path):
+            if not include_hidden:
+                dirnames[:] = [d for d in dirnames if not d.startswith(".")]
+
+            for filename in filenames:
+                if time.monotonic() > deadline:
+                    truncated = True
+                    errors.append("Search aborted after reaching 10s execution limit.")
+                    stop_search = True
+                    break
+                if not include_hidden and filename.startswith("."):
+                    continue
+
+                abs_path = os.path.join(dirpath, filename)
+                rel_path = os.path.relpath(abs_path, root_path)
+
+                if using_default_excludes:
+                    path_parts = rel_path.replace("\\", "/").split("/")
+                    if any(part in self.DEFAULT_EXCLUDE_DIRS for part in path_parts):
+                        continue
+
+                if using_default_includes:
+                    ext = os.path.splitext(filename)[1].lower()
+                    if ext not in allowed_exts and filename not in self.ALWAYS_INCLUDE_FILENAMES:
+                        continue
+
+                if os.path.splitext(filename)[1].lower() in binary_exts:
+                    continue
+
+                if not self._should_include(rel_path, include_patterns, exclude_patterns):
+                    continue
+
+                try:
+                    size = os.path.getsize(abs_path)
+                except OSError:
+                    errors.append(f"Failed to stat file: {rel_path}")
+                    continue
+
+                if size > max_file_size:
+                    errors.append(f"Skipped (too large): {rel_path} ({size} bytes)")
+                    continue
+
+                files_scanned += 1
+                matches_for_file = 0
+
+                try:
+                    with open(abs_path, "r", encoding="utf-8", errors="replace") as file_obj:
+                        stop_current_file = False
+                        for line_number, line in enumerate(file_obj, start=1):
+                            if time.monotonic() > deadline:
+                                truncated = True
+                                errors.append("Search aborted after reaching 10s execution limit.")
+                                stop_search = True
+                                stop_current_file = True
+                                break
+                            iter_matches = list(compiled.finditer(line))
+                            if not iter_matches:
+                                continue
+
+                            # Enforce per-file cap
+                            remaining_per_file = max_per_file - matches_for_file
+                            if remaining_per_file <= 0:
+                                truncated = True
+                                truncated_count += len(iter_matches)
+                                stop_current_file = True
+                                break
+
+                            spans = [
+                                [match.start(), match.end()] for match in iter_matches[:remaining_per_file]
+                            ]
+                            dropped_from_file = len(iter_matches) - len(spans)
+                            if dropped_from_file > 0:
+                                truncated = True
+                                truncated_count += dropped_from_file
+
+                            # Enforce global cap
+                            remaining_global = max_results - len(matches)
+                            if remaining_global <= 0:
+                                truncated = True
+                                truncated_count += len(spans)
+                                stop_search = True
+                                break
+
+                            if len(spans) > remaining_global:
+                                truncated = True
+                                truncated_count += len(spans) - remaining_global
+                                spans = spans[:remaining_global]
+                                stop_search = True
+
+                            if spans:
+                                clean_line = line.rstrip("\n")
+                                truncated_line = clean_line
+                                line_truncated = False
+                                if len(clean_line) > max_line_length:
+                                    truncated_line = clean_line[:max_line_length] + "..."
+                                    line_truncated = True
+
+                                matches.append(
+                                    {
+                                        "path": abs_path,
+                                        "relative_path": rel_path,
+                                        "line_number": line_number,
+                                        "line": truncated_line,
+                                        "match_spans": spans,
+                                        "match_count": len(spans),
+                                        "line_truncated": line_truncated,
+                                    }
+                                )
+                                matches_for_file += len(spans)
+
+                            if stop_search or matches_for_file >= max_per_file:
+                                break
+                        if stop_current_file:
+                            break
+                except (OSError, UnicodeDecodeError):
+                    errors.append(f"Failed to read file: {rel_path}")
+                    continue
+
+                if stop_search:
+                    break
+            if stop_search:
+                break
+
+        total_matches = len(matches) + truncated_count
+
+        return {
+            "event": "file_search_response",
+            "root_path": root_path,
+            "query": query,
+            "match_case": match_case,
+            "regex": use_regex,
+            "whole_word": whole_word,
+            "include_patterns": include_patterns,
+            "exclude_patterns": exclude_patterns,
+            "matches": matches,
+            "matches_returned": len(matches),
+            "total_matches": total_matches,
+            "files_scanned": files_scanned,
+            "truncated": truncated,
+            "truncated_count": truncated_count,
+            "max_results": max_results,
+            "max_matches_per_file": max_per_file,
+            "errors": errors,
+        }
+
+    @staticmethod
+    def _normalize_patterns(patterns: Optional[Any]) -> List[str]:
+        if not patterns:
+            return []
+        if isinstance(patterns, str):
+            patterns = [patterns]
+        normalized: List[str] = []
+        for pattern in patterns:
+            if isinstance(pattern, str) and pattern.strip():
+                normalized.append(pattern.strip())
+        return normalized
+
+    @staticmethod
+    def _should_include(
+        relative_path: str,
+        include_patterns: List[str],
+        exclude_patterns: List[str],
+    ) -> bool:
+        if include_patterns:
+            if not any(fnmatch.fnmatch(relative_path, pat) for pat in include_patterns):
+                return False
+        if exclude_patterns:
+            if any(fnmatch.fnmatch(relative_path, pat) for pat in exclude_patterns):
+                return False
+        return True
+
+    @staticmethod
+    def _clamp_int(
+        value: Optional[Any],
+        *,
+        default: int,
+        min_value: int,
+        max_value: int,
+    ) -> int:
+        try:
+            coerced = int(value)
+        except (TypeError, ValueError):
+            coerced = default
+        return max(min_value, min(max_value, coerced))
+
+
 class ContentRequestHandler(AsyncHandler):
     """Handler for requesting content by hash for caching optimization."""
     
@@ -434,4 +1091,4 @@ def cache_content(content_hash: str, content: str) -> None:
 
 def get_cached_content(content_hash: str) -> str:
     """Get cached content by hash."""
-    return _content_cache.get(content_hash)
+    return _content_cache.get(content_hash)

portacode/connection/handlers/project_state/git_manager.py

@@ -61,6 +61,9 @@ class GitManager:
         self.is_git_repo = False
         self._change_callback = change_callback
         
+        # Track git processes spawned by this specific GitManager instance
+        self._tracked_git_processes = set()
+        
         # Periodic monitoring attributes
         self._monitoring_task: Optional[asyncio.Task] = None
         self._cached_status_summary: Optional[Dict[str, int]] = None
@@ -84,9 +87,29 @@ class GitManager:
             self.repo = Repo(self.project_path)
             self.is_git_repo = True
             logger.info("Initialized Git repo for project: %s", self.project_path)
+            
+            # Track initial git processes after repo creation
+            self._track_current_git_processes()
+            
         except (InvalidGitRepositoryError, Exception) as e:
             logger.debug("Not a Git repository or Git error: %s", e)
     
+    def _track_current_git_processes(self):
+        """Track currently running git cat-file processes for this repo."""
+        try:
+            import psutil
+            for proc in psutil.process_iter(['pid', 'cmdline', 'cwd']):
+                try:
+                    cmdline = proc.info['cmdline']
+                    if (cmdline and len(cmdline) >= 2 and 
+                        'git' in cmdline[0] and 'cat-file' in cmdline[1] and
+                        proc.info['cwd'] == self.project_path):
+                        self._tracked_git_processes.add(proc.pid)
+                except (psutil.NoSuchProcess, psutil.AccessDenied):
+                    continue
+        except Exception as e:
+            logger.debug("Error tracking git processes: %s", e)
+    
     def reinitialize(self):
         """Reinitialize git repo detection (useful when .git directory is created after initialization)."""
         logger.info("Reinitializing git repo detection for: %s", self.project_path)
@@ -1933,4 +1956,43 @@ class GitManager:
     def cleanup(self):
         """Cleanup resources when GitManager is being destroyed."""
         logger.info("Cleaning up GitManager for %s", self.project_path)
-        self.stop_periodic_monitoring()
+        self.stop_periodic_monitoring()
+        
+        # CRITICAL: Close GitPython repo to cleanup git cat-file processes
+        if self.repo:
+            try:
+                # Force cleanup of git command processes
+                if hasattr(self.repo.git, 'clear_cache'):
+                    self.repo.git.clear_cache()
+                self.repo.close()
+                logger.info("Successfully closed GitPython repo for %s", self.project_path)
+            except Exception as e:
+                logger.warning("Error during git repo cleanup for %s: %s", self.project_path, e)
+            finally:
+                self.repo = None
+        
+        # Clean up only the git processes tracked by this specific GitManager instance
+        try:
+            import psutil
+            killed_count = 0
+            
+            for pid in list(self._tracked_git_processes):
+                try:
+                    proc = psutil.Process(pid)
+                    if proc.is_running():
+                        proc.terminate()
+                        killed_count += 1
+                        logger.info("Terminated tracked git process %d", pid)
+                except (psutil.NoSuchProcess, psutil.AccessDenied):
+                    pass
+                finally:
+                    self._tracked_git_processes.discard(pid)
+            
+            if killed_count > 0:
+                logger.info("Cleaned up %d tracked git processes for session", killed_count)
+                
+        except Exception as e:
+            logger.warning("Error cleaning up tracked git processes: %s", e)
+        
+        # Clear the tracking set
+        self._tracked_git_processes.clear()

portacode/connection/terminal.py

@@ -33,6 +33,7 @@ from .handlers import (
     DirectoryListHandler,
     FileInfoHandler,
     FileDeleteHandler,
+    FileSearchHandler,
     FileRenameHandler,
     ContentRequestHandler,
     ProjectStateFolderExpandHandler,
@@ -439,6 +440,7 @@ class TerminalManager:
         self._command_registry.register(ProjectAwareFileCreateHandler)  # Use project-aware version
         self._command_registry.register(ProjectAwareFolderCreateHandler)  # Use project-aware version
         self._command_registry.register(FileRenameHandler)
+        self._command_registry.register(FileSearchHandler)
         self._command_registry.register(ContentRequestHandler)
         # Project state handlers
         self._command_registry.register(ProjectStateFolderExpandHandler)
@@ -828,4 +830,4 @@ class TerminalManager:
             await self._request_client_sessions()
             logger.info("Client session request sent after reconnection")
         except Exception as exc:
-            logger.error("Failed to handle reconnection: %s", exc) 
+            logger.error("Failed to handle reconnection: %s", exc) 

{portacode-1.3.34.dist-info → portacode-1.3.36.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: portacode
-Version: 1.3.34
+Version: 1.3.36
 Summary: Portacode CLI client and SDK
 Home-page: https://github.com/portacode/portacode
 Author: Meena Erian

{portacode-1.3.34.dist-info → portacode-1.3.36.dist-info}/RECORD

@@ -1,7 +1,7 @@
 portacode/README.md,sha256=4dKtpvR8LNgZPVz37GmkQCMWIr_u25Ao63iW56s7Ke4,775
 portacode/__init__.py,sha256=oB3sV1wXr-um-RXio73UG8E5Xx6cF2ZVJveqjNmC-vQ,1086
 portacode/__main__.py,sha256=jmHTGC1hzmo9iKJLv-SSYe9BSIbPPZ2IOpecI03PlTs,296
-portacode/_version.py,sha256=FzZk-nydxD5WVgixf72x-Q7yZ53GL7Ll3WvZRoS7J5w,706
+portacode/_version.py,sha256=xMaRDFNnwKIiV9r1azRWTk8TGkEmXiCDj3mIjOKCWQ0,706
 portacode/cli.py,sha256=eDqcZMVFHKzqqWxedhhx8ylu5WMVCLqeJQkbPR7RcJE,16333
 portacode/data.py,sha256=5-s291bv8J354myaHm1Y7CQZTZyRzMU3TGe5U4hb-FA,1591
 portacode/keypair.py,sha256=PAcOYqlVLOoZTPYi6LvLjfsY6BkrWbLOhSZLb8r5sHs,3635
@@ -11,13 +11,13 @@ portacode/connection/README.md,sha256=f9rbuIEKa7cTm9C98rCiBbEtbiIXQU11esGSNhSMiJ
 portacode/connection/__init__.py,sha256=atqcVGkViIEd7pRa6cP2do07RJOM0UWpbnz5zXjGktU,250
 portacode/connection/client.py,sha256=Uqsy5xzN0j5AY0xkYs2_qd67N7SUopcnpkCbkmOnMgg,9102
 portacode/connection/multiplex.py,sha256=L-TxqJ_ZEbfNEfu1cwxgJ5vUdyRzZjsMy2Kx1diiZys,5237
-portacode/connection/terminal.py,sha256=iz4bi9pppxsiAiOtXEkffcHoyaWkvRG9BkojUyfZ784,42421
+portacode/connection/terminal.py,sha256=kUoB2bGe-ZmGnL5fDUuv8JRYr0Qt8rjYaERJW0ahZRQ,42504
 portacode/connection/handlers/README.md,sha256=HsLZG1QK1JNm67HsgL6WoDg9nxzKXxwkc5fJPFJdX5g,12169
-portacode/connection/handlers/WEBSOCKET_PROTOCOL.md,sha256=U-d58S-X2r5T6QAu-6NOzCIJg71FIj_vmOdUGCWFIhw,68211
-portacode/connection/handlers/__init__.py,sha256=4nv3Z4TGYjWcauKPWsbL_FbrTXApI94V7j6oiU1Vv-o,2144
+portacode/connection/handlers/WEBSOCKET_PROTOCOL.md,sha256=xnVrY5uR00z88Q1mBJp-RHVGBoUDS0CWn0PD_D49LDk,74136
+portacode/connection/handlers/__init__.py,sha256=U8OLLKNPZHca03Arhzbqfs2xzDObQD_Ze3zr5j_G_a4,2193
 portacode/connection/handlers/base.py,sha256=oENFb-Fcfzwk99Qx8gJQriEMiwSxwygwjOiuCH36hM4,10231
 portacode/connection/handlers/chunked_content.py,sha256=h6hXRmxSeOgnIxoU8CkmvEf2Odv-ajPrpHIe_W3GKcA,9251
-portacode/connection/handlers/file_handlers.py,sha256=kBj-o3HkqZTKsju2ZxRgBB3Ke42dn4sDQQKGO7APYf8,15451
+portacode/connection/handlers/file_handlers.py,sha256=nAJH8nXnX07xxD28ngLpgIUzcTuRwZBNpEGEKdRqohw,39507
 portacode/connection/handlers/project_aware_file_handlers.py,sha256=n0M2WmBNWPwzigdIkyZiAsePUQGXVqYSsDyOxm-Nsok,9253
 portacode/connection/handlers/project_state_handlers.py,sha256=v6ZefGW9i7n1aZLq2jOGumJIjYb6aHlPI4m1jkYewm8,1686
 portacode/connection/handlers/registry.py,sha256=qXGE60sYEWg6ZtVQzFcZ5YI2XWR6lMgw4hAL9x5qR1I,6181
@@ -28,7 +28,7 @@ portacode/connection/handlers/terminal_handlers.py,sha256=HRwHW1GiqG1NtHVEqXHKaY
 portacode/connection/handlers/project_state/README.md,sha256=trdd4ig6ungmwH5SpbSLfyxbL-QgPlGNU-_XrMEiXtw,10114
 portacode/connection/handlers/project_state/__init__.py,sha256=5ucIqk6Iclqg6bKkL8r_wVs5Tlt6B9J7yQH6yQUt7gc,2541
 portacode/connection/handlers/project_state/file_system_watcher.py,sha256=2zingW9BoNKRijghHC2eHHdRoyDRdLmIl1yH1y-iuF8,10831
-portacode/connection/handlers/project_state/git_manager.py,sha256=GO0AEXzHEaKOBGZP043_V2KgGz8zqmSahWJ5KHgC_Cs,88845
+portacode/connection/handlers/project_state/git_manager.py,sha256=QGaGR8Y1NJx2vj0t33mEs7dxTWNDGVgu__eq1A3dhcQ,91508
 portacode/connection/handlers/project_state/handlers.py,sha256=ay9D2KCPnPx-Luhx3_VAVq_HVFgLDDBwJvgaiKeseak,37889
 portacode/connection/handlers/project_state/manager.py,sha256=XX3wMgGdPbRgBBs_R1dXtQ4D9j-itETrJR_6IfBeDU0,61296
 portacode/connection/handlers/project_state/models.py,sha256=EZTKvxHKs8QlQUbzI0u2IqfzfRRXZixUIDBwTGCJATI,4313
@@ -38,7 +38,7 @@ portacode/static/js/utils/ntp-clock.js,sha256=KMeHGT-IlUSlxVRZZ899z25dQCJh6EJbgX
 portacode/utils/NTP_ARCHITECTURE.md,sha256=WkESTbz5SNAgdmDKk3DrHMhtYOPji_Kt3_a9arWdRig,3894
 portacode/utils/__init__.py,sha256=NgBlWTuNJESfIYJzP_3adI1yJQJR0XJLRpSdVNaBAN0,33
 portacode/utils/ntp_clock.py,sha256=6QJOVZr9VQuxIyJt9KNG4dR-nZ3bKNyipMxjqDWP89Y,5152
-portacode-1.3.34.dist-info/licenses/LICENSE,sha256=2FGbCnUDgRYuQTkB1O1dUUpu5CVAjK1j4_p6ack9Z54,1066
+portacode-1.3.36.dist-info/licenses/LICENSE,sha256=2FGbCnUDgRYuQTkB1O1dUUpu5CVAjK1j4_p6ack9Z54,1066
 test_modules/README.md,sha256=Do_agkm9WhSzueXjRAkV_xEj6Emy5zB3N3VKY5Roce8,9274
 test_modules/__init__.py,sha256=1LcbHodIHsB0g-g4NGjSn6AMuCoGbymvXPYLOb6Z7F0,53
 test_modules/test_device_online.py,sha256=yiSyVaMwKAugqIX_ZIxmLXiOlmA_8IRXiUp12YmpB98,1653
@@ -63,8 +63,8 @@ testing_framework/core/playwright_manager.py,sha256=kWKmlxzftDY0ZWS891zlHu_Ctdw7
 testing_framework/core/runner.py,sha256=j2QwNJmAxVBmJvcbVS7DgPJUKPNzqfLmt_4NNdaKmZU,19297
 testing_framework/core/shared_cli_manager.py,sha256=BESSNtyQb7BOlaOvZmm04T8Uezjms4KCBs2MzTxvzYQ,8790
 testing_framework/core/test_discovery.py,sha256=2FZ9fJ8Dp5dloA-fkgXoJ_gCMC_nYPBnA3Hs2xlagzM,4928
-portacode-1.3.34.dist-info/METADATA,sha256=X9OAC5yDMG6Teny3L5pYj-SQz43H9U0QRHN5BfJhzaY,6989
-portacode-1.3.34.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-portacode-1.3.34.dist-info/entry_points.txt,sha256=lLUUL-BM6_wwe44Xv0__5NQ1BnAz6jWjSMFvZdWW3zU,48
-portacode-1.3.34.dist-info/top_level.txt,sha256=TGhTYUxfW8SyVZc_zGgzjzc24gGT7nSw8Qf73liVRKM,41
-portacode-1.3.34.dist-info/RECORD,,
+portacode-1.3.36.dist-info/METADATA,sha256=fUdZf3CBnFpQGgD1719zgM9lDC9yo6ryhlYX4-FrPyE,6989
+portacode-1.3.36.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+portacode-1.3.36.dist-info/entry_points.txt,sha256=lLUUL-BM6_wwe44Xv0__5NQ1BnAz6jWjSMFvZdWW3zU,48
+portacode-1.3.36.dist-info/top_level.txt,sha256=TGhTYUxfW8SyVZc_zGgzjzc24gGT7nSw8Qf73liVRKM,41
+portacode-1.3.36.dist-info/RECORD,,