deepagents 0.3.8__py3-none-any.whl → 0.3.10__py3-none-any.whl

deepagents/backends/utils.py

@@ -219,17 +219,26 @@ def truncate_if_too_long(result: list[str] | str) -> list[str] | str:
     return result
 
 
-def _validate_path(path: str | None) -> str:
-    """Validate and normalize a path.
+def _normalize_path(path: str | None) -> str:
+    """Normalize a path to canonical form.
+
+    Converts path to absolute form starting with /, removes trailing slashes
+    (except for root), and validates that the path is not empty.
 
     Args:
-        path: Path to validate
+        path: Path to normalize (None defaults to "/")
 
     Returns:
-        Normalized path starting with /
+        Normalized path starting with / (without trailing slash unless it's root)
 
     Raises:
-        ValueError: If path is invalid
+        ValueError: If path is invalid (empty string after strip)
+
+    Example:
+        _normalize_path(None) -> "/"
+        _normalize_path("/dir/") -> "/dir"
+        _normalize_path("dir") -> "/dir"
+        _normalize_path("/") -> "/"
     """
     path = path or "/"
     if not path or path.strip() == "":
@@ -237,12 +246,43 @@ def _validate_path(path: str | None) -> str:
 
     normalized = path if path.startswith("/") else "/" + path
 
-    if not normalized.endswith("/"):
-        normalized += "/"
+    # Only root should have trailing slash
+    if normalized != "/" and normalized.endswith("/"):
+        normalized = normalized.rstrip("/")
 
     return normalized
 
 
+def _filter_files_by_path(files: dict[str, Any], normalized_path: str) -> dict[str, Any]:
+    """Filter files dict by normalized path, handling exact file matches and directory prefixes.
+
+    Expects a normalized path from _normalize_path (no trailing slash except root).
+
+    Args:
+        files: Dictionary mapping file paths to file data
+        normalized_path: Normalized path from _normalize_path (e.g., "/", "/dir", "/dir/file")
+
+    Returns:
+        Filtered dictionary of files matching the path
+
+    Example:
+        files = {"/dir/file": {...}, "/dir/other": {...}}
+        _filter_files_by_path(files, "/dir/file")  # Returns {"/dir/file": {...}}
+        _filter_files_by_path(files, "/dir")       # Returns both files
+    """
+    # Check if path matches an exact file
+    if normalized_path in files:
+        return {normalized_path: files[normalized_path]}
+
+    # Otherwise treat as directory prefix
+    if normalized_path == "/":
+        # Root directory - match all files starting with /
+        return {fp: fd for fp, fd in files.items() if fp.startswith("/")}
+    # Non-root directory - add trailing slash for prefix matching
+    dir_prefix = normalized_path + "/"
+    return {fp: fd for fp, fd in files.items() if fp.startswith(dir_prefix)}
+
+
 def _glob_search_files(
     files: dict[str, Any],
     pattern: str,
@@ -267,11 +307,11 @@ def _glob_search_files(
         ```
     """
     try:
-        normalized_path = _validate_path(path)
+        normalized_path = _normalize_path(path)
     except ValueError:
         return "No files found"
 
-    filtered = {fp: fd for fp, fd in files.items() if fp.startswith(normalized_path)}
+    filtered = _filter_files_by_path(files, normalized_path)
 
     # Respect standard glob semantics:
     # - Patterns without path separators (e.g., "*.py") match only in the current
@@ -281,9 +321,17 @@ def _glob_search_files(
 
     matches = []
     for file_path, file_data in filtered.items():
-        relative = file_path[len(normalized_path) :].lstrip("/")
-        if not relative:
+        # Compute relative path for glob matching
+        # If normalized_path is "/dir", we want "/dir/file.txt" -> "file.txt"
+        # If normalized_path is "/dir/file.txt" (exact file), we want "file.txt"
+        if normalized_path == "/":
+            relative = file_path[1:]  # Remove leading slash
+        elif file_path == normalized_path:
+            # Exact file match - use just the filename
             relative = file_path.split("/")[-1]
+        else:
+            # Directory prefix - strip the directory path
+            relative = file_path[len(normalized_path) + 1 :]  # +1 for the slash
 
         if wcglob.globmatch(relative, effective_pattern, flags=wcglob.BRACE | wcglob.GLOBSTAR):
             matches.append((file_path, file_data["modified_at"]))
@@ -357,11 +405,11 @@ def _grep_search_files(
         return f"Invalid regex pattern: {e}"
 
     try:
-        normalized_path = _validate_path(path)
+        normalized_path = _normalize_path(path)
     except ValueError:
         return "No matches found"
 
-    filtered = {fp: fd for fp, fd in files.items() if fp.startswith(normalized_path)}
+    filtered = _filter_files_by_path(files, normalized_path)
 
     if glob:
         filtered = {fp: fd for fp, fd in filtered.items() if wcglob.globmatch(Path(fp).name, glob, flags=wcglob.BRACE)}
@@ -390,21 +438,18 @@ def grep_matches_from_files(
 ) -> list[GrepMatch] | str:
     """Return structured grep matches from an in-memory files mapping.
 
-    Returns a list of GrepMatch on success, or a string for invalid inputs
-    (e.g., invalid regex). We deliberately do not raise here to keep backends
-    non-throwing in tool contexts and preserve user-facing error messages.
-    """
-    try:
-        regex = re.compile(pattern)
-    except re.error as e:
-        return f"Invalid regex pattern: {e}"
+    Performs literal text search (not regex).
 
+    Returns a list of GrepMatch on success, or a string for invalid inputs.
+    We deliberately do not raise here to keep backends non-throwing in tool
+    contexts and preserve user-facing error messages.
+    """
     try:
-        normalized_path = _validate_path(path)
+        normalized_path = _normalize_path(path)
     except ValueError:
         return []
 
-    filtered = {fp: fd for fp, fd in files.items() if fp.startswith(normalized_path)}
+    filtered = _filter_files_by_path(files, normalized_path)
 
     if glob:
         filtered = {fp: fd for fp, fd in filtered.items() if wcglob.globmatch(Path(fp).name, glob, flags=wcglob.BRACE)}
@@ -412,7 +457,7 @@ def grep_matches_from_files(
     matches: list[GrepMatch] = []
     for file_path, file_data in filtered.items():
         for line_num, line in enumerate(file_data["content"], 1):
-            if regex.search(line):
+            if pattern in line:  # Simple substring search for literal matching
                 matches.append({"path": file_path, "line": int(line_num), "text": line})
     return matches