stashai 0.1.332__tar.gz → 0.1.334__tar.gz

{stashai-0.1.332/stashai.egg-info → stashai-0.1.334}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stashai
-Version: 0.1.332
+Version: 0.1.334
 Summary: CLI for Stash — shared memory for AI coding agents
 Author: Fergana Labs
 License: MIT

{stashai-0.1.332 → stashai-0.1.334}/cli/tests/test_app_vfs.py

@@ -190,21 +190,22 @@ def test_app_vfs_grep_no_match_stops_and_chain():
     assert result.stderr == ""
 
 
-def test_app_vfs_grep_rejects_bre_escapes_loudly():
-    """Patterns compile as extended regex, where BRE's `\\|` means a literal pipe —
-    a default-grep caller writing `foo\\|bar` would silently match nothing (this
-    burned Heavi's agent in prod). The shell must refuse with a correction, never
-    return a clean no-match exit 1."""
+def test_app_vfs_grep_accepts_bre_operator_escapes():
+    """Patterns compile as extended regex, but default-grep callers write BRE —
+    `foo\\|bar` (this burned Heavi's agent in prod, twice: first as a silent
+    no-match, then as a hard refusal that cost the agent its search). Both
+    dialects intend an operator there, so the escape must just work; `-F` stays
+    the literal-match path."""
     shell, _client = _shell()
 
-    result = shell.run("grep -ri 'hello\\|missing' /")
+    assert shell.run("grep -ri 'hello\\|missing' /").exit_code == 0
 
-    assert result.exit_code == 2
-    assert "extended" in result.stderr
-
-    # The same intent written as extended regex works.
+    # The same intent written as extended regex still works.
     assert shell.run("grep -ri 'hello|missing' /").exit_code == 0
 
+    # A literal backslash escape that is not a BRE operator is left alone.
+    assert shell.run("grep -ri 'hello\\d' /").exit_code == 1
+
 
 def test_app_vfs_grep_accepts_extended_and_fixed_string_flags():
     shell, _client = _shell()

{stashai-0.1.332 → stashai-0.1.334}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "stashai"
-version = "0.1.332"
+version = "0.1.334"
 description = "CLI for Stash — shared memory for AI coding agents"
 readme = "README.md"
 requires-python = ">=3.11"

{stashai-0.1.332 → stashai-0.1.334/stashai.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stashai
-Version: 0.1.332
+Version: 0.1.334
 Summary: CLI for Stash — shared memory for AI coding agents
 Author: Fergana Labs
 License: MIT

{stashai-0.1.332 → stashai-0.1.334}/stashvfs/__init__.py

@@ -2,7 +2,7 @@
 contract that backs them. Shared by the `stash vfs` CLI command and the
 `/api/v1/me/vfs` endpoint."""
 
-from .client import MachineVfsClient, VfsClient, VfsClientError
+from .client import MachineVfsClient, VfsClient, VfsClientError, VfsScanBudget
 from .model import MountError, StashVfsModel
 from .shell import SkillAppVfsShell, VfsCommandResult
 
@@ -14,4 +14,5 @@ __all__ = [
     "VfsClient",
     "VfsClientError",
     "VfsCommandResult",
+    "VfsScanBudget",
 ]

{stashai-0.1.332 → stashai-0.1.334}/stashvfs/client.py

@@ -25,6 +25,16 @@ class VfsClientError(Exception):
         super().__init__(str(detail))
 
 
+class VfsScanBudget(Exception):
+    """A document read was refused because the command's scan budget ran out.
+
+    Raised by clients that meter reads (the server-side VFS) for reads issued
+    inside `scan_calls`. The shell stops the grep sweep at this point and
+    reports the results so far with a loud truncation warning — an org-wide
+    sweep degrades to a partial answer instead of an aborted command.
+    """
+
+
 class VfsClient(Protocol):
     """Everything `StashVfsModel` reads. Listing calls run during `refresh()`;
     the rest are lazy loaders fired when a file's bytes are first read."""

{stashai-0.1.332 → stashai-0.1.334}/stashvfs/model.py

@@ -15,7 +15,7 @@ from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass, field
 from datetime import datetime
 
-from .client import MachineVfsClient, VfsClient, VfsClientError
+from .client import MachineVfsClient, VfsClient, VfsClientError, VfsScanBudget
 
 BytesLoader = Callable[[], bytes]
 
@@ -57,7 +57,7 @@ class VfsNode:
     # Set when `prefetch` already tried this loader and it failed. `read_file`
     # re-raises it rather than fetching again — a second fetch would hit the
     # provider twice and, server-side, spend the document budget twice.
-    error: VfsClientError | None = None
+    error: VfsClientError | VfsScanBudget | None = None
 
     @property
     def is_dir(self) -> bool:
@@ -180,16 +180,16 @@ class StashVfsModel:
         if len(pending) < 2:
             return
 
-        def load(node: VfsNode) -> tuple[VfsNode, bytes | VfsClientError]:
+        def load(node: VfsNode) -> tuple[VfsNode, bytes | VfsClientError | VfsScanBudget]:
             try:
                 return node, node.loader()
-            except VfsClientError as e:
+            except (VfsClientError, VfsScanBudget) as e:
                 return node, e
 
         workers = min(PREFETCH_CONCURRENCY, len(pending))
         with ThreadPoolExecutor(max_workers=workers) as pool:
             for node, result in pool.map(load, pending):
-                if isinstance(result, VfsClientError):
+                if isinstance(result, (VfsClientError, VfsScanBudget)):
                     node.error = result
                     continue
                 node.content = result

{stashai-0.1.332 → stashai-0.1.334}/stashvfs/shell.py

@@ -10,7 +10,7 @@ import time
 from dataclasses import dataclass
 from datetime import datetime
 
-from .client import VfsClientError
+from .client import VfsClientError, VfsScanBudget
 from .model import MountError, StashVfsModel
 
 
@@ -435,9 +435,8 @@ class SkillAppVfsShell:
         if fixed_strings:
             regex = re.compile(re.escape(pattern), flags)
         else:
-            _reject_bre_escapes(pattern)
             try:
-                regex = re.compile(pattern, flags)
+                regex = re.compile(_translate_bre_escapes(pattern), flags)
             except re.error as e:
                 raise VfsShellError(str(e)) from e
 
@@ -459,27 +458,44 @@ class SkillAppVfsShell:
             paths = ["."]
         matches = []
         roots = []
+        # Resolve every root before reading anything (listings are unbudgeted),
+        # so a budget stop can say how much of the sweep went unsearched.
+        sweep: list[list[str]] = []
+        total_files = 0
+        for raw_path in paths:
+            path = self._resolve_path(raw_path)
+            roots.append(path)
+            node = self.model._get_node(path)
+            file_paths = [path] if node.is_file else self._file_paths(path) if recursive else []
+            if node.is_dir and not recursive:
+                raise VfsShellError(f"{raw_path}: is a directory")
+            sweep.append(file_paths)
+            total_files += len(file_paths)
         docs_scanned = 0
+        budget_hit = False
         # The per-document reads below are the mechanics of one search, not
         # documents the user asked to see — scan_calls tags them so analytics
         # skip them, and record_search writes the single search event that
         # stands in for the whole sweep.
         with self.model.client.scan_calls():
-            for raw_path in paths:
-                path = self._resolve_path(raw_path)
-                roots.append(path)
-                node = self.model._get_node(path)
-                file_paths = [path] if node.is_file else self._file_paths(path) if recursive else []
-                if node.is_dir and not recursive:
-                    raise VfsShellError(f"{raw_path}: is a directory")
+            for file_paths in sweep:
+                if budget_hit:
+                    break
                 self.model.prefetch(file_paths)
                 for file_path in file_paths:
-                    docs_scanned += 1
                     try:
                         text = self._read_text(file_path)
+                    except VfsScanBudget:
+                        # Out of reads mid-sweep: report what was found rather
+                        # than aborting, but never silently — the warning below
+                        # marks the results partial.
+                        budget_hit = True
+                        break
                     except VfsClientError as e:
+                        docs_scanned += 1
                         self._warn(f"{name}: {file_path}: {e.detail}")
                         continue
+                    docs_scanned += 1
                     matches.append(
                         _grep_text(
                             regex,
@@ -492,6 +508,12 @@ class SkillAppVfsShell:
                         )
                     )
         self.model.client.record_search(pattern, roots, docs_scanned)
+        if budget_hit:
+            self._warn(
+                f"{name}: stopped after reading {docs_scanned} of {total_files} files "
+                "(server scan budget); matches shown are partial — narrow the paths to "
+                "search the rest"
+            )
         output = "".join(matches)
         if not output:
             raise VfsShellExit(1)
@@ -860,23 +882,28 @@ def _render_printf_template(template: str, values: list[str]) -> tuple[str, int]
     return "".join(output), used
 
 
-def _reject_bre_escapes(pattern: str) -> None:
+def _translate_bre_escapes(pattern: str) -> str:
     """Patterns compile as Python (extended) regex, where BRE's operator escapes
-    `\\|` `\\(` `\\)` mean the *literal* character — so a caller writing default-grep
-    syntax like `foo\\|bar` would silently match nothing. Refuse loudly instead."""
+    `\\|` `\\(` `\\)` would mean the *literal* character — so a caller writing
+    default-grep syntax like `foo\\|bar` would silently match nothing. Both
+    dialects intend an operator there, so treat the escape as the operator;
+    `-F` remains the way to match the character literally."""
+    output: list[str] = []
     index = 0
-    while index < len(pattern) - 1:
-        if pattern[index] != "\\":
-            index += 1
+    while index < len(pattern):
+        char = pattern[index]
+        if char == "\\" and index + 1 < len(pattern):
+            escaped = pattern[index + 1]
+            if escaped in "|()":
+                output.append(escaped)
+            else:
+                output.append(char)
+                output.append(escaped)
+            index += 2
             continue
-        escaped = pattern[index + 1]
-        if escaped in "|()":
-            raise VfsShellError(
-                f"pattern escape \\{escaped} is BRE syntax; patterns here are extended "
-                f"regex — use {escaped} as the operator, or -F to match text literally",
-                exit_code=2,
-            )
-        index += 2
+        output.append(char)
+        index += 1
+    return "".join(output)
 
 
 def _grep_text(