tensor-grep 1.63.2__tar.gz → 1.63.4__tar.gz

{tensor_grep-1.63.2 → tensor_grep-1.63.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tensor-grep
-Version: 1.63.2
+Version: 1.63.4
 Requires-Dist: typer>=0.12,<0.26
 Requires-Dist: rich>=13.0
 Requires-Dist: mcp>=1.2.0

{tensor_grep-1.63.2 → tensor_grep-1.63.4}/pyproject.toml

@@ -482,12 +482,14 @@ version_variables = [
 
 
 
+
+
 
 
 
 [project]
 name = "tensor-grep"
-version = "1.63.2"
+version = "1.63.4"
 description = "High-performance grep-compatible CLI with Rust, GPU, and AST/NLP routing"
 readme = { file = "rust_core/README.md", content-type = "text/markdown" }
 requires-python = ">=3.11"

{tensor_grep-1.63.2 → tensor_grep-1.63.4}/rust_core/Cargo.lock

@@ -1579,7 +1579,7 @@ dependencies = [
 
 [[package]]
 name = "tensor_grep_rs"
-version = "1.63.2"
+version = "1.63.4"
 dependencies = [
  "aho-corasick",
  "anyhow",

{tensor_grep-1.63.2 → tensor_grep-1.63.4}/rust_core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tensor_grep_rs"
-version = "1.63.2"
+version = "1.63.4"
 edition = "2021"
 description = "Rust core engine for tensor-grep"
 license = "Apache-2.0"
@@ -390,6 +390,8 @@ path = "src/bin/tg_search_fast.rs"
 
 
 
+
+
 
 
 

{tensor_grep-1.63.2 → tensor_grep-1.63.4}/src/tensor_grep/cli/orient_capsule.py

@@ -194,10 +194,27 @@ def _detect_vendored_subtrees(rm: dict[str, Any]) -> dict[str, dict[str, Any]]:
     _code_files, _resolved_imports, reverse_importers = _code_files_and_import_graph(rm)
     code_file_set = set(_code_files)
 
+    # Precompute each code file's path-parts relative to root ONCE, on the SAME lexical basis the
+    # candidate_dirs scan above used (`Path(f).relative_to(root)`; root is already resolved). Subtree
+    # membership is then a cheap tuple-prefix test -- NO per-(subtree, file) filesystem resolve. The
+    # old `_path_is_relative_to(Path(f), abs_dir)` did two `.resolve()` (realpath) syscalls per pair,
+    # i.e. O(subtrees x files) realpath calls: ~15% of `tg agent` wall on an 872-file repo and
+    # pathological on WSL 9p mounts (profile 2026-07-11). A file not lexically under root never
+    # contributed a candidate dir, so it cannot belong to any detected subtree -- skipping it here is
+    # consistent with how the subtrees were found.
+    code_rel_parts: list[tuple[str, tuple[str, ...]]] = []
+    for f in code_file_set:
+        try:
+            code_rel_parts.append((f, Path(f).relative_to(root).parts))
+        except ValueError:
+            continue
+
     result: dict[str, dict[str, Any]] = {}
     for rel_dir in subtree_rel_roots:
         abs_dir = root / rel_dir
-        tree_files = {f for f in code_file_set if _repo_map._path_is_relative_to(Path(f), abs_dir)}
+        prefix = rel_dir.parts
+        depth = len(prefix)
+        tree_files = {f for f, parts in code_rel_parts if parts[:depth] == prefix}
         if not tree_files:
             continue
         # An import-island needs POSITIVE evidence of an internally-cohesive-but-externally-isolated

{tensor_grep-1.63.2 → tensor_grep-1.63.4}/src/tensor_grep/cli/repo_map.py

@@ -1661,12 +1661,29 @@ def _python_dynamic_import_entries(tree: ast.AST) -> list[dict[str, Any]]:
     return entries
 
 
+@lru_cache(maxsize=2048)
+def _cached_ast_parse(source: str) -> ast.Module:
+    """Content-addressed AST parse cache. `build_agent_capsule` parses each Python file 2-3x
+    across phases -- once in the map-build imports/symbols pass and again in the caller/blast-radius
+    consumer scan (and the `tg imports`/`importers` extractors) -- all on the SAME source read the
+    same way (`path.read_text(encoding="utf-8")`). Profiling `tg agent` on an 872-file repo (2026-
+    07-11) showed ~40% of the wall in `ast.parse` + `ast.walk` over those duplicate parses (1512
+    parses for ~783 files). Keying on the source TEXT (not the path) is staleness-free: an edited
+    file has different content -> a fresh key -> a fresh parse, so this stays correct even under the
+    reused session-daemon process (no mtime races). Callers only ever READ the tree (`tree.body` /
+    `ast.walk` + `isinstance`, no mutation -- audited), so sharing one parsed tree is safe. Raises
+    on invalid syntax exactly like `ast.parse` (lru_cache does not cache the exception, so a
+    syntax-error file simply re-raises + re-parses each time -- the caller's try/except is
+    unchanged). Bounded at 2048 entries to cap resident memory in the long-lived daemon."""
+    return ast.parse(source)
+
+
 def _python_imports_and_symbols(path: Path) -> tuple[list[str], list[dict[str, Any]]]:
     if path.suffix != ".py":
         return [], []
 
     try:
-        tree = ast.parse(path.read_text(encoding="utf-8"))
+        tree = _cached_ast_parse(path.read_text(encoding="utf-8"))
     except (OSError, SyntaxError, UnicodeDecodeError):
         return [], []
 
@@ -3119,7 +3136,7 @@ def _python_file_imports_symbol_from_definition(
     repo_root: Path | str | None = None,
 ) -> bool:
     try:
-        tree = ast.parse(source)
+        tree = _cached_ast_parse(source)
     except SyntaxError:
         return False
 
@@ -3314,7 +3331,7 @@ def _python_import_update_target(
         return None
 
     try:
-        tree = ast.parse(source)
+        tree = _cached_ast_parse(source)
     except SyntaxError:
         return None
 
@@ -4197,7 +4214,7 @@ def _python_references_and_calls(
 
     try:
         source = path.read_text(encoding="utf-8")
-        tree = ast.parse(source)
+        tree = _cached_ast_parse(source)
     except (OSError, SyntaxError, UnicodeDecodeError):
         return [], []
 
@@ -4264,7 +4281,7 @@ def _python_provider_alias_calls(path: Path, symbol: str) -> list[dict[str, Any]
 
     try:
         source = path.read_text(encoding="utf-8")
-        tree = ast.parse(source)
+        tree = _cached_ast_parse(source)
     except (OSError, SyntaxError, UnicodeDecodeError):
         return []
 
@@ -5207,7 +5224,7 @@ def _python_symbol_sources(path: Path, symbol: str) -> list[dict[str, Any]]:
 
     try:
         source = path.read_text(encoding="utf-8")
-        tree = ast.parse(source)
+        tree = _cached_ast_parse(source)
     except (OSError, SyntaxError, UnicodeDecodeError):
         return []
 
@@ -5674,7 +5691,7 @@ def _python_imports_with_lines(path: Path) -> list[dict[str, Any]]:
     if file_size > _max_parse_bytes():
         return []
     try:
-        tree = ast.parse(path.read_text(encoding="utf-8"))
+        tree = _cached_ast_parse(path.read_text(encoding="utf-8"))
     except (OSError, SyntaxError, UnicodeDecodeError):
         return []
 
@@ -8973,7 +8990,7 @@ def _best_test_function_candidate(
 def _python_test_function_candidates(test_path: str) -> tuple[str, ...]:
     path = Path(test_path)
     try:
-        tree = ast.parse(path.read_text(encoding="utf-8"))
+        tree = _cached_ast_parse(path.read_text(encoding="utf-8"))
     except (OSError, SyntaxError, UnicodeDecodeError):
         return ()
 
@@ -8996,7 +9013,7 @@ def _python_test_function_candidates(test_path: str) -> tuple[str, ...]:
 def _python_parametrized_test_function_candidates(test_path: str) -> tuple[str, ...]:
     path = Path(test_path)
     try:
-        tree = ast.parse(path.read_text(encoding="utf-8"))
+        tree = _cached_ast_parse(path.read_text(encoding="utf-8"))
     except (OSError, SyntaxError, UnicodeDecodeError):
         return ()