tensor-grep 1.76.4__tar.gz → 1.76.6__tar.gz

{tensor_grep-1.76.4 → tensor_grep-1.76.6}/PKG-INFO

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

{tensor_grep-1.76.4 → tensor_grep-1.76.6}/pyproject.toml

@@ -532,12 +532,14 @@ version_variables = [
 
 
 
+
+
 
 
 
 [project]
 name = "tensor-grep"
-version = "1.76.4"
+version = "1.76.6"
 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.76.4 → tensor_grep-1.76.6}/rust_core/Cargo.lock

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

{tensor_grep-1.76.4 → tensor_grep-1.76.6}/rust_core/Cargo.toml

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

{tensor_grep-1.76.4 → tensor_grep-1.76.6}/src/tensor_grep/cli/agent_capsule.py

@@ -2341,9 +2341,19 @@ def build_agent_capsule_from_map(
     # Local import avoids a module-level circular import (orient_capsule imports repo_map, which
     # this module also imports) -- same discipline repo_map.build_context_render's own reuse of
     # this helper uses, and the same reasoning as the _suggested_scope_from_map import below.
-    from tensor_grep.cli.orient_capsule import _apply_ignore_globs
+    from tensor_grep.cli.orient_capsule import _apply_ignore_globs, _detect_vendored_subtrees
 
     rm = _apply_ignore_globs(rm, ignore)
+    # #179: compute the SAME auto-detected vendor/skill/tool-config tree set ONCE, here, against the
+    # final (already `--ignore`-filtered) `rm`, and thread it through every `_suggested_scope_from_map`
+    # call below plus the `suggested_ignore` build near the end of this function. Previously each
+    # `_suggested_scope_from_map(rm)` call below ran with no exclusion set at all (defaulting to
+    # "nothing excluded"), while `suggested_ignore` independently re-ran `_detect_vendored_subtrees(rm)`
+    # for the SAME `rm` -- so `suggested_scope` could point an agent straight at a tree `suggested_
+    # ignore` already flagged in the very same capsule (#179, the tg-agent/context-render sibling of
+    # orient's #168/#606 fix). Sourcing both fields from one shared call makes them provably
+    # consistent, not just coincidentally so, and also drops a redundant second detection pass.
+    deweighted_trees = _detect_vendored_subtrees(rm)
     resolved_path = str(rm["path"])
     requested_semantic_provider = semantic_provider
     effective_semantic_provider = (
@@ -2374,7 +2384,7 @@ def build_agent_capsule_from_map(
     ):
         from tensor_grep.cli.orient_capsule import _suggested_scope_from_map
 
-        suggested_scope_from_map = _suggested_scope_from_map(rm)
+        suggested_scope_from_map = _suggested_scope_from_map(rm, deweighted_trees=deweighted_trees)
         if suggested_scope_from_map is not None:
             payload["suggested_scope"] = suggested_scope_from_map
     # PR-1 (1D): whether the underlying repo scan itself (not the capsule's own snippet/token
@@ -2617,7 +2627,7 @@ def build_agent_capsule_from_map(
     if ambiguity.get("requires_confirmation") and not payload.get("suggested_scope"):
         from tensor_grep.cli.orient_capsule import _suggested_scope_from_map
 
-        tie_suggested_scope = _suggested_scope_from_map(rm)
+        tie_suggested_scope = _suggested_scope_from_map(rm, deweighted_trees=deweighted_trees)
         if tie_suggested_scope is None:
             # `tied_alternatives` (not `ambiguity["tied_alternative_targets"]`) is the definitive
             # source: `requires_confirmation` is only ever True from the `if tied_alternatives:`
@@ -2874,21 +2884,19 @@ def build_agent_capsule_from_map(
     # skill/tool-config subtree roots as ready-to-paste `--ignore` globs. `tg agent` already runs
     # the SAME de-weight during ranking (`_build_context_pack_from_map`'s own `auto_deweight` pass,
     # repo_map.py) but, pre-M2, never surfaced the glob hint itself -- an agent had to hand-derive
-    # `--ignore` globs or fall back to `tg orient` first. Recompute `_detect_vendored_subtrees`
-    # against the SAME (already `--ignore`-filtered) `rm` the ranking pass used above, and reuse
-    # orient's exact glob-builder (`_suggested_ignore_from_deweighted_trees`) -- never a second,
-    # independently hand-rolled hint that could drift from what `tg orient` would say for the same
-    # repo. `_detect_vendored_subtrees` reads only `rm`'s already-in-hand file/import lists plus a
-    # bounded number of manifest-marker existence checks (no new directory walk), so this is cheap
-    # relative to the rest of the capsule build. Additive + conditional, same shape as
-    # `suggested_scope` above: present only when non-empty, so a capsule with nothing deweighted
-    # stays byte-identical to a pre-M2 build.
-    from tensor_grep.cli.orient_capsule import (
-        _detect_vendored_subtrees,
-        _suggested_ignore_from_deweighted_trees,
-    )
-
-    suggested_ignore = _suggested_ignore_from_deweighted_trees(_detect_vendored_subtrees(rm))
+    # `--ignore` globs or fall back to `tg orient` first. Reuse the `deweighted_trees` set already
+    # computed once, near the top of this function (#179), against the SAME (already
+    # `--ignore`-filtered) `rm` the ranking pass used above, and feed it into orient's exact
+    # glob-builder (`_suggested_ignore_from_deweighted_trees`) -- never a second, independently
+    # hand-rolled hint that could drift from what `tg orient` would say for the same repo, and never
+    # a second `_detect_vendored_subtrees` walk over the same `rm` (#179 dedupes what was previously
+    # two independent calls into one shared result, which is also what makes `suggested_scope` above
+    # provably consistent with this hint rather than coincidentally so). Additive + conditional, same
+    # shape as `suggested_scope` above: present only when non-empty, so a capsule with nothing
+    # deweighted stays byte-identical to a pre-M2 build.
+    from tensor_grep.cli.orient_capsule import _suggested_ignore_from_deweighted_trees
+
+    suggested_ignore = _suggested_ignore_from_deweighted_trees(deweighted_trees)
     if suggested_ignore:
         result["suggested_ignore"] = suggested_ignore
     # DAR: additive CONDITIONAL keys, same pattern as scan_limit/partial above -- zero deps (or

{tensor_grep-1.76.4 → tensor_grep-1.76.6}/src/tensor_grep/cli/orient_capsule.py

@@ -589,19 +589,52 @@ def _top_level_dir(file_path: str, root: Path) -> str | None:
     return parts[0]
 
 
-def _suggested_scope_from_map(rm: dict[str, Any]) -> dict[str, Any] | None:
+def _file_in_any_tree(file_path: str, tree_roots: list[str]) -> bool:
+    """True if `file_path` lives inside any of `tree_roots` (absolute directory paths -- the
+    ``_detect_vendored_subtrees`` dict keys). Standalone helper (#168) rather than reusing
+    `_central_files_from_map`'s inline tree-membership loop, so that function's existing,
+    already-tested de-weight logic is left untouched."""
+    candidate = Path(file_path)
+    for tree_root in tree_roots:
+        try:
+            candidate.relative_to(tree_root)
+        except ValueError:
+            continue
+        return True
+    return False
+
+
+def _suggested_scope_from_map(
+    rm: dict[str, Any],
+    *,
+    deweighted_trees: dict[str, dict[str, Any]] | None = None,
+) -> dict[str, Any] | None:
     """Centrality-weighted directory rollup: sum each code file's composite centrality
     (`_file_centrality_scores`) up to its top-level directory, rank directories, and suggest the
     top one only when it clearly outranks the runner-up. Returns None (never a guess) when there
     are no candidate subdirectories, the signal is entirely flat (all zero), or the top two
     directories are tied/near-tied. Callers gate the call itself on the repo map's
-    ``scan_limit.possibly_truncated`` -- a complete scan has nothing left to narrow."""
+    ``scan_limit.possibly_truncated`` -- a complete scan has nothing left to narrow.
+
+    ``deweighted_trees`` (#168): the same auto-detected vendor/skill/tool-config subtree set
+    ``_detect_vendored_subtrees`` produces for ``suggested_ignore`` (e.g. ``.claude/**`` on a
+    Claude-Code-harness repo whose scan truncates). A file inside any of these trees is EXCLUDED
+    from the directory rollup entirely -- not merely de-weighted -- so `suggested_scope` can never
+    point an agent at the exact tree `suggested_ignore` already says to ignore; the two fields must
+    never contradict each other. This only shrinks the candidate set: whatever directory remains is
+    still ranked on the raw, un-de-weighted score (preserving the SUB-2 design -- see
+    `_central_files_from_map`'s docstring). ``None``/omitted -- the default -- means "nothing to
+    exclude" and reproduces the pre-#168 behavior exactly; the `agent_capsule.py` and `repo_map.py`
+    call sites do not thread a deweight set through yet and are unaffected by this parameter."""
     code_files, centrality = _file_centrality_scores(rm)
     if not code_files:
         return None
     root = Path(str(rm.get("path", ".")))
+    tree_roots = list(deweighted_trees.keys()) if deweighted_trees else []
     dir_scores: dict[str, float] = {}
     for file_path in code_files:
+        if tree_roots and _file_in_any_tree(file_path, tree_roots):
+            continue  # #168: never roll an ignored tree's files into a scope candidate
         top_dir = _top_level_dir(file_path, root)
         if top_dir is None:
             continue
@@ -770,7 +803,13 @@ def build_orient_capsule_from_map(
     scan_possibly_truncated = bool(
         isinstance(scan_limit_info, dict) and scan_limit_info.get("possibly_truncated")
     )
-    suggested_scope = _suggested_scope_from_map(rm) if scan_possibly_truncated else None
+    # `deweighted_trees` (#168) is threaded through so suggested_scope can never point an agent at
+    # the same tree suggested_ignore (below) already says to ignore -- the two fields must agree.
+    suggested_scope = (
+        _suggested_scope_from_map(rm, deweighted_trees=deweighted_trees)
+        if scan_possibly_truncated
+        else None
+    )
     # The capsule's own simplified `scan_limit` int (see the docstring above): the cap that
     # produced `rm`, read back off the map itself rather than threaded through as a second,
     # independently-suppliable parameter.

{tensor_grep-1.76.4 → tensor_grep-1.76.6}/src/tensor_grep/cli/repo_map.py

@@ -12470,11 +12470,21 @@ def build_context_render(
         # import avoids the module-level cycle (orient_capsule imports this module), exactly like the
         # `_apply_ignore_globs` reuse above. Additive + conditional: absent unless the scan was
         # truncated AND a clear winner exists, so a non-truncated render stays byte-identical.
+        #
+        # #179: also thread in the SAME auto-detected vendor/skill/tool-config tree set `tg orient`
+        # (#168/#606) and `tg agent` (agent_capsule.py's own #179 fix) exclude from their own
+        # suggested_scope rollup -- otherwise this wrapper (behind `tg context-render`, and any other
+        # `include_suggested_scope=True` caller) could point an agent at a tree the sibling commands
+        # already know to avoid, on the exact same repo map.
         scan_limit = repo_map.get("scan_limit")
         if isinstance(scan_limit, dict) and scan_limit.get("possibly_truncated"):
-            from tensor_grep.cli.orient_capsule import _suggested_scope_from_map
+            from tensor_grep.cli.orient_capsule import (
+                _detect_vendored_subtrees,
+                _suggested_scope_from_map,
+            )
 
-            suggested_scope = _suggested_scope_from_map(repo_map)
+            deweighted_trees = _detect_vendored_subtrees(repo_map)
+            suggested_scope = _suggested_scope_from_map(repo_map, deweighted_trees=deweighted_trees)
             if suggested_scope is not None:
                 render["suggested_scope"] = suggested_scope
     return render