descry-codegraph 0.3.2__tar.gz → 0.3.4__tar.gz

{descry_codegraph-0.3.2 → descry_codegraph-0.3.4}/CHANGELOG.md

@@ -6,6 +6,34 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+## [0.3.4] — 2026-10-23
+
+### Fixed
+
+- `search` answers what semantic search finds when the keywords find
+  nothing: the semantic pass ran because they found little, and its
+  results were then dropped ("No matches"). It now searches under
+  `lang`, `crate`, `type` and `exclude_tests` as the keyword side does; its
+  results were merged unfiltered.
+- `search --type` with a type the graph has none of, or one descry does
+  not know, matches nothing, as an unknown `lang` does; it was ignored and
+  every type answered. The CLI lists the types it takes.
+- `flow --target` takes a node ID as well as a name; a node ID was never
+  found, and the trace said nothing of it.
+
+## [0.3.3] — 2026-10-23
+
+### Fixed
+
+- A `bin` directory is indexed: Dart keeps its entry points there and Rust
+  its extra binaries (`src/bin/`). Only the `bin` of a .NET project or of
+  an Eclipse project, beside its project file or `.classpath`, is left out
+  as build output; every `bin` was.
+- A Dart call of a standard type's name without `new`, `StringBuffer()`,
+  makes an instance of that type, as `new StringBuffer()` does. Calls on it
+  were taken as calls on an unknown receiver and listed as possible calls
+  of every project method of their name (`toString`, `write`, `close`).
+
 ## [0.3.2] — 2026-10-23
 
 ### Fixed

{descry_codegraph-0.3.2 → descry_codegraph-0.3.4}/CLAUDE.md

@@ -23,7 +23,7 @@ just test tests/test_handlers.py::test_index     # one test
 just test -k "cross_lang and not slow"           # by expression
 ```
 
-Python 3.11+ required (enforced by `pyproject.toml`). Pre-commit gate: `just lint && just fmt && just test` all pass (2810 tests currently — a drop is a regression signal).
+Python 3.11+ required (enforced by `pyproject.toml`). Pre-commit gate: `just lint && just fmt && just test` all pass (2822 tests currently — a drop is a regression signal).
 
 Invoke the tool while developing:
 

{descry_codegraph-0.3.2 → descry_codegraph-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: descry-codegraph
-Version: 0.3.2
+Version: 0.3.4
 Summary: Codebase knowledge graph: polyglot indexer, semantic search, call-graph analysis
 Project-URL: Homepage, https://github.com/06chaynes/descry
 Project-URL: Repository, https://github.com/06chaynes/descry
@@ -267,7 +267,7 @@ For customization, add a `.descry.toml` to your project root.
 
 ```toml
 [project]
-# OPTIONAL — REPLACES the 25-element default. Leave unset to keep defaults
+# OPTIONAL — REPLACES the 24-element default. Leave unset to keep defaults
 # (.git, .gradle, .next, .svelte-kit, .venv, node_modules, target, build, …).
 # excluded_dirs = ["target", "node_modules", "dist", "build", "vendor"]
 # OPTIONAL — in a git repository, files git ignores are not indexed.
@@ -393,7 +393,7 @@ Share of project calls resolved without SCIP, measured on public repositories at
 | C# | serilog `bebc771`, Newtonsoft.Json `52fa3ae` (`Src/Newtonsoft.Json`) | 94%, 91% |
 | C | jq `a19efdd`, libuv `954c1d1` | 99%, 79% |
 | C++ | leveldb `7ee830d`, fmt `c4927e6` | 97%, 86% |
-| Dart | shelf `b2cb503`, riverpod `1efba1c` (`packages/riverpod`) | 93%, 91% |
+| Dart | shelf `b2cb503`, riverpod `1efba1c` (`packages/riverpod`) | 95%, 91% |
 | Ruby | rack `a9833c8`, sinatra `cb22afd` | 70%, 39% |
 
 The remainder is unresolved, not wrong: of 450 resolved edges drawn at random from these repositories and read against the source, every one reaches the definition the call reaches. Ruby is low because the language declares no types and calls inside DSL blocks run with another `self`; libuv because most of its functions exist once for Unix and once for Windows, and the build files, not the source, choose between them.

{descry_codegraph-0.3.2 → descry_codegraph-0.3.4}/README.md

@@ -202,7 +202,7 @@ For customization, add a `.descry.toml` to your project root.
 
 ```toml
 [project]
-# OPTIONAL — REPLACES the 25-element default. Leave unset to keep defaults
+# OPTIONAL — REPLACES the 24-element default. Leave unset to keep defaults
 # (.git, .gradle, .next, .svelte-kit, .venv, node_modules, target, build, …).
 # excluded_dirs = ["target", "node_modules", "dist", "build", "vendor"]
 # OPTIONAL — in a git repository, files git ignores are not indexed.
@@ -328,7 +328,7 @@ Share of project calls resolved without SCIP, measured on public repositories at
 | C# | serilog `bebc771`, Newtonsoft.Json `52fa3ae` (`Src/Newtonsoft.Json`) | 94%, 91% |
 | C | jq `a19efdd`, libuv `954c1d1` | 99%, 79% |
 | C++ | leveldb `7ee830d`, fmt `c4927e6` | 97%, 86% |
-| Dart | shelf `b2cb503`, riverpod `1efba1c` (`packages/riverpod`) | 93%, 91% |
+| Dart | shelf `b2cb503`, riverpod `1efba1c` (`packages/riverpod`) | 95%, 91% |
 | Ruby | rack `a9833c8`, sinatra `cb22afd` | 70%, 39% |
 
 The remainder is unresolved, not wrong: of 450 resolved edges drawn at random from these repositories and read against the source, every one reaches the definition the call reaches. Ruby is low because the language declares no types and calls inside DSL blocks run with another `self`; libuv because most of its functions exist once for Unix and once for Windows, and the build files, not the source, choose between them.

{descry_codegraph-0.3.2 → descry_codegraph-0.3.4}/claude-skill/descry/references/cli-reference.md

@@ -24,7 +24,7 @@ descry search <terms...>
     [--limit N]                  # default 10
     [--lang rust|ts|py|...]
     [--crate NAME]
-    [--type Function|Class|Method|...]
+    [--type function|class|method|constant|file|all]
     [--exclude-tests]
 
 descry semantic <query>
@@ -49,7 +49,7 @@ descry callees <name> [--limit N]           # default 20
 descry flow <start>
     [--direction forward|backward]   # default forward
     [--depth N]                       # default 3, capped by [query] max_depth
-    [--target NAME]                   # stop early if reached
+    [--target SYMBOL]                 # stop early if reached (name or node ID)
     [--inline-threshold N]            # inline callee source below N tokens
 
 descry path <start> <end>

{descry_codegraph-0.3.2 → descry_codegraph-0.3.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "descry-codegraph"
-version = "0.3.2"
+version = "0.3.4"
 description = "Codebase knowledge graph: polyglot indexer, semantic search, call-graph analysis"
 requires-python = ">=3.11"
 authors = [{name = "Christian Haynes"}]

{descry_codegraph-0.3.2 → descry_codegraph-0.3.4}/src/descry/__init__.py

@@ -1,4 +1,4 @@
 """Descry — Codebase knowledge graph: polyglot indexer, semantic search, call-graph analysis."""
 
-__version__ = "0.3.2"
+__version__ = "0.3.4"
 __all__ = ["__version__"]

{descry_codegraph-0.3.2 → descry_codegraph-0.3.4}/src/descry/cli.py

@@ -308,7 +308,9 @@ def main():
         default=3,
         help="Levels of calls below the start (default: 3)",
     )
-    sub.add_argument("--target", default=None, help="Target symbol to reach")
+    sub.add_argument(
+        "--target", default=None, help="Symbol to reach, by name or node ID"
+    )
     sub.add_argument(
         "--inline-threshold",
         type=int,
@@ -329,7 +331,13 @@ def main():
     sub.add_argument("--limit", type=int, default=10, help="Max results (default: 10)")
     sub.add_argument("--lang", default=None, help="Filter by language")
     sub.add_argument("--crate", default=None, help="Filter by crate")
-    sub.add_argument("--type", default=None, help="Filter by symbol type")
+    sub.add_argument(
+        "--type",
+        default=None,
+        type=str.lower,
+        choices=["function", "class", "method", "constant", "file", "all"],
+        help="Filter by symbol type",
+    )
     sub.add_argument(
         "--exclude-tests", action="store_true", help="Exclude test symbols"
     )

{descry_codegraph-0.3.2 → descry_codegraph-0.3.4}/src/descry/embeddings.py

@@ -774,7 +774,9 @@ class SemanticSearcher:
         self.embeddings = embeddings / np.where(norms == 0, 1, norms)
         logger.info("Embeddings generated successfully")
 
-    def search(self, query: str, limit: int = 10, min_score: float = 0.3) -> list:
+    def search(
+        self, query: str, limit: int = 10, min_score: float = 0.3, keep=None
+    ) -> list:
         """Search for nodes semantically similar to the query.
 
         Args:
@@ -782,6 +784,7 @@ class SemanticSearcher:
             limit: Maximum number of results
             min_score: Minimum final score, i.e. cosine similarity after
                 the in-degree and type boosts are added (may exceed 1).
+            keep: The node IDs results may have, None for any.
 
         Returns:
             List of (node, score) tuples sorted by relevance
@@ -826,10 +829,19 @@ class SemanticSearcher:
             np.linalg.norm(self.embeddings, axis=1) * np.linalg.norm(query_embedding)
         )
 
+        if keep is not None:
+            # Nodes outside `keep` never enter the pool
+            kept = np.fromiter(
+                (n["id"] in keep for n in self.nodes), bool, len(self.nodes)
+            )
+            similarities = np.where(kept, similarities, -np.inf)
+            if not kept.any():
+                return []
+
         # Take a candidate pool by base score, then apply min_score to the
         # final score, so a node whose boosts (worth up to +0.17) lift it over
         # the threshold is kept.
-        pool = min(len(similarities), limit * 3)
+        pool = min(len(similarities) if keep is None else int(kept.sum()), limit * 3)
         top_indices = np.argpartition(-similarities, pool - 1)[:pool]
         top_indices = top_indices[np.argsort(-similarities[top_indices])]
 

{descry_codegraph-0.3.2 → descry_codegraph-0.3.4}/src/descry/generate.py

@@ -18650,6 +18650,15 @@ class CallResolver:
             if self.standard[lang].key(callee, source_id) == callee:
                 held = self._returned_type(constructed, source_id)
                 self._result = held or self._result
+        elif verdict[1] == _EXTERNAL and not origin and lang == "dart":
+            # Dart constructs without `new`: a call of a standard type's
+            # name gives an instance of it.
+            library = self.standard[lang]
+            if (
+                callee in library.data["types"]
+                and library.key(callee, source_id) == callee
+            ):
+                self._result = self._returned_type(callee, source_id) or self._result
         elif verdict[1] == _EXTERNAL and not origin and lang == "typescript":
             known, value = self._js_global(callee, source_id)
             if known:
@@ -24878,12 +24887,19 @@ class CodeGraphBuilder:
         for root, dirs, files in os.walk(self.root_dir, followlinks=False):
             dirs.sort()
             files.sort()
-            # Filter by name first (excluded dirs, dotfiles), and by what git
-            # ignores.
+            # Filter by name first (excluded dirs, dotfiles, the build output
+            # of a .NET or an Eclipse project), and by what git ignores.
+            # `bin` holds sources in Dart and Rust.
+            built = any(
+                f.endswith((".csproj", ".vbproj", ".fsproj")) or f == ".classpath"
+                for f in files
+            )
             dirs[:] = [
                 d
                 for d in kept(root, dirs)
-                if not d.startswith(".") and d not in self.excluded_dirs
+                if not d.startswith(".")
+                and d not in self.excluded_dirs
+                and not (built and d == "bin")
             ]
             # Then filter by realpath containment — drop directories that are
             # symlinks pointing outside the project root.

{descry_codegraph-0.3.2 → descry_codegraph-0.3.4}/src/descry/handlers.py

@@ -92,8 +92,8 @@ _DEFAULT_EXCLUDED_DIRS = {
     "venv",
     # Go
     "vendor",
-    # .NET
-    "bin",
+    # .NET (its `bin`, and an Eclipse project's, is skipped beside the
+    # project file)
     "obj",
     # Dart / Flutter
     ".dart_tool",
@@ -2086,23 +2086,23 @@ class DescryService:
                 # and respects the cache lock).
                 searcher = await self._get_semantic_searcher()
                 if searcher is not None:
+                    # Under the filters the keyword side has
                     semantic_results = await asyncio.to_thread(
                         searcher.search,
                         " ".join(terms),
                         limit=limit * 2,
                         min_score=0.25,
+                        keep=q.filtered_ids(lang, crate, symbol_type, exclude_tests),
                     )
             except Exception as e:  # noqa: BLE001 — boundary over the embedding backend; search degrades to keyword-only
                 logger.warning(f"Semantic search failed, using keyword only: {e}")
 
-        if semantic_results and tfidf_results:
+        if semantic_results:
             combined = reciprocal_rank_fusion(tfidf_results, semantic_results)
             results = [node for node, _ in combined[:limit]]
             method = "hybrid"
-        elif tfidf_results:
-            results = tfidf_results[:limit]
         else:
-            results = []
+            results = tfidf_results[:limit]
 
         return {"ok": True, "error": None, "results": results, "method": method}
 

{descry_codegraph-0.3.2 → descry_codegraph-0.3.4}/src/descry/query.py

@@ -1318,7 +1318,8 @@ class GraphQuerier:
         once, at the first level that reaches it, and met again as `seen`,
         the level of that entry (the start is level 0).
         Returns ``(root, path, cut)``: the tree, the node IDs from the start
-        to the first node named ``target``, and why it stopped early
+        to the first node ``target`` names, by name or node ID, and why it
+        stopped early
         ("timeout", "node limit") or None."""
         start_time = time.time()
 
@@ -1353,7 +1354,7 @@ class GraphQuerier:
 
         root = tree_node(start_id, None)
         paths = {start_id: [start_id]}
-        if target and root["name"] == target:
+        if target in (root["name"], root["id"]):
             return root, paths[start_id], None
         level = [root]
         for _ in range(depth):
@@ -1378,7 +1379,7 @@ class GraphQuerier:
                     child = tree_node(child_id, marks.get(child_id))
                     paths[child_id] = [*paths[parent["id"]], child_id]
                     parent["children"].append(child)
-                    if target and child["name"] == target:
+                    if target in (child["name"], child["id"]):
                         return root, paths[child_id], None
                     next_level.append(child)
             level = next_level
@@ -1500,7 +1501,7 @@ class GraphQuerier:
         cut (why the trace stopped early, when it did). Each tree node has: id,
         name, type, tokens, file, line, code, lang, candidates, children,
         more, more_possible, and `seen`, the level its entry is at, where it
-        is placed there already. The trace stops at the first node named `target`.
+        is placed there already. The trace stops at the first node `target` names, by name or node ID.
         """
         if timeout_ms is None:
             timeout_ms = self._timeout_ms
@@ -1666,6 +1667,33 @@ class GraphQuerier:
             idf[term] = math.log((total_docs + 1) / (df + 1)) + 1
         return idf
 
+    def filtered_ids(
+        self, lang=None, crate=None, symbol_type=None, exclude_tests=False
+    ):
+        """The IDs of the nodes `search_docs`'s filters keep, None when none
+        is given: the language, the crate or module, the type, and no tests."""
+        if not (lang or crate or symbol_type or exclude_tests):
+            return None
+        self._ensure_filter_indices()
+        kept = set(self.nodes.keys())
+        if exclude_tests and self._index_is_test:
+            kept -= self._index_is_test
+        if crate:
+            kept &= self._index_by_crate.get(crate, set())
+        if lang and lang != "all":
+            lang = _LANG_ALIASES.get(lang.lower(), lang.lower())
+            kept &= self._index_by_lang.get(lang, set())
+        if symbol_type and symbol_type != "all":
+            type_map = {
+                "function": "Function",
+                "class": "Class",
+                "method": "Method",
+                "constant": "Constant",
+                "file": "File",
+            }
+            kept &= self._index_by_type.get(type_map.get(symbol_type.lower()), set())
+        return kept
+
     def search_docs(
         self, query_terms, lang=None, crate=None, symbol_type=None, exclude_tests=False
     ):
@@ -1695,38 +1723,10 @@ class GraphQuerier:
         if num_terms == 0:
             return []
 
-        # Apply filters if any specified
-        if lang or crate or symbol_type or exclude_tests:
-            self._ensure_filter_indices()
-            candidate_ids = set(self.nodes.keys())
-
-            # Filter out test files and functions if requested
-            if exclude_tests and self._index_is_test:
-                candidate_ids -= self._index_is_test
-
-            if crate:
-                # If crate filter specified but doesn't exist, return empty results
-                if crate not in self._index_by_crate:
-                    return []
-                candidate_ids &= self._index_by_crate[crate]
-            if lang and lang != "all":
-                lang = _LANG_ALIASES.get(lang.lower(), lang.lower())
-                candidate_ids &= self._index_by_lang.get(lang, set())
-            if symbol_type and symbol_type != "all":
-                type_map = {
-                    "function": "Function",
-                    "class": "Class",
-                    "method": "Method",
-                    "constant": "Constant",
-                    "file": "File",
-                }
-                type_key = type_map.get(symbol_type.lower())
-                if type_key and type_key in self._index_by_type:
-                    candidate_ids &= self._index_by_type[type_key]
-
-            candidates = [self.nodes[nid] for nid in candidate_ids]
-        else:
-            candidates = self.data["nodes"]
+        kept = self.filtered_ids(lang, crate, symbol_type, exclude_tests)
+        candidates = (
+            self.data["nodes"] if kept is None else [self.nodes[nid] for nid in kept]
+        )
 
         for node in candidates:
             score = 0.0

{descry_codegraph-0.3.2 → descry_codegraph-0.3.4}/tests/test_cli.py

@@ -225,3 +225,29 @@ class TestCliStopped:
         index.send_signal(signal.SIGHUP)
         assert not indexer_tree.grandchild_exited(timeout=1)
         assert index.poll() is None
+
+
+class TestSearchType:
+    """`--type` takes the types descry has, in any case, and refuses others."""
+
+    def test_a_type_is_passed_lowercased(self, monkeypatch):
+        seen = {}
+
+        class Service:
+            async def search(self, **kwargs):
+                seen.update(kwargs)
+                return "ok"
+
+        monkeypatch.setattr(cli, "_make_service", Service)
+        monkeypatch.setattr(
+            sys, "argv", ["descry", "search", "x", "--type", "Function"]
+        )
+        cli.main()
+        assert seen["symbol_type"] == "function"
+
+    def test_an_unknown_type_is_refused(self, monkeypatch, capsys):
+        monkeypatch.setattr(sys, "argv", ["descry", "search", "x", "--type", "struct"])
+        with pytest.raises(SystemExit) as exit_:
+            cli.main()
+        assert exit_.value.code == 2
+        assert "invalid choice: 'struct'" in capsys.readouterr().err

{descry_codegraph-0.3.2 → descry_codegraph-0.3.4}/tests/test_embeddings.py

@@ -434,6 +434,26 @@ class TestSearchScoring:
         with pytest.raises(EmbeddingCacheMismatch):
             s.search("anything", limit=3)
 
+    def test_kept_nodes_are_the_pool_others_never_enter(self, fake_model, graph_writer):
+        """A filter applies before the pool is cut, so a kept node far down
+        the ranking is still found."""
+        s = SemanticSearcher(str(graph_writer()))
+        dim = s.embeddings.shape[1]
+        s.embeddings = np.zeros((len(s.nodes), dim), dtype="float32")
+        s.embeddings[:, 0] = 1.0
+        last = len(s.nodes) - 1
+        s.embeddings[last] = 0.0
+        s.embeddings[last, 1] = 1.0
+        q = np.zeros(dim, dtype="float32")
+        q[0], q[1] = 1.0, 0.1
+        s.model = FakeSentenceTransformer(dim=dim, prompts={})
+        s.model.encode = lambda texts, **kw: q.reshape(1, -1)
+        wanted = s.nodes[last]["id"]
+
+        hits = s.search("q", limit=1, min_score=-1.0, keep={wanted})
+        assert [n["id"] for n, _ in hits] == [wanted]
+        assert s.search("q", limit=1, min_score=-1.0, keep=set()) == []
+
     def test_results_are_sorted_and_limited(self, fake_model, graph_writer):
         s = SemanticSearcher(str(graph_writer()))
         hits = s.search("alpha", limit=2, min_score=-1.0)

{descry_codegraph-0.3.2 → descry_codegraph-0.3.4}/tests/test_generate.py

@@ -30858,3 +30858,51 @@ def test_a_form_feed_ends_no_line(tmp_path):
     }
     assert len(found) == 11
     assert set(found.values()) == {3}
+
+
+def test_a_bin_directory_is_indexed_unless_it_is_dotnet_build_output(tmp_path):
+    """Dart's `bin/` and Rust's `src/bin/` hold sources; a .NET or an
+    Eclipse project's `bin/` holds what it builds."""
+    from descry.handlers import _DEFAULT_EXCLUDED_DIRS
+
+    files = {
+        "dart/bin/main.dart": "void main() {}\n",
+        "rust/src/bin/tool.rs": "fn main() {}\n",
+        "net/App.csproj": "<Project />\n",
+        "net/bin/Debug/Copied.cs": "class Copied {}\n",
+        "eclipse/.classpath": "<classpath />\n",
+        "eclipse/bin/generated/Copied.java": "class Copied {}\n",
+    }
+    for rel, source in files.items():
+        (tmp_path / rel).parent.mkdir(parents=True, exist_ok=True)
+        (tmp_path / rel).write_text(source)
+    builder = CodeGraphBuilder(tmp_path, excluded_dirs=set(_DEFAULT_EXCLUDED_DIRS))
+    builder.process_directory()
+    found = {n["id"] for n in builder.nodes if n["type"] == "File"}
+    assert {"FILE:dart/bin/main.dart", "FILE:rust/src/bin/tool.rs"} <= found
+    assert not any(
+        "/bin/" in f for f in found if f.startswith(("FILE:net", "FILE:eclipse"))
+    )
+
+
+def test_a_dart_call_of_a_standard_type_constructs_it(tmp_path):
+    """Dart needs no `new`: `StringBuffer()` makes a StringBuffer, whose
+    `toString` is the library's, not a project method of that name."""
+    builder = _index(
+        tmp_path,
+        {
+            "pubspec.yaml": "name: x\n",
+            "lib/a.dart": """
+                class Oops {
+                  @override
+                  String toString() => 'oops';
+                }
+
+                String build() {
+                  final sb = StringBuffer();
+                  return sb.toString();
+                }
+            """,
+        },
+    )
+    assert _calls(builder, "FILE:lib/a.dart::build") == []

{descry_codegraph-0.3.2 → descry_codegraph-0.3.4}/tests/test_handlers.py

@@ -1709,3 +1709,41 @@ async def test_a_context_budget_below_one_is_refused(tmp_path, bound):
     result = await DescryService(config).context("FILE:x.py::f", depth=2, **{bound: 0})
     assert isinstance(result, ServiceError)
     assert f"{bound} must be at least 1, got 0." in result
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    ("terms", "lang", "found"),
+    [
+        (["who", "talks", "to", "nothing"], None, ["FILE:x.py::f", "FILE:y.rs::g"]),
+        (["who", "talks", "to", "nothing"], "python", ["FILE:x.py::f"]),
+        # The keywords find `f` too; the semantic side is still filtered
+        (["f"], "python", ["FILE:x.py::f"]),
+    ],
+)
+async def test_search_keeps_semantic_matches_no_keyword_finds(
+    tmp_path, terms, lang, found
+):
+    """The semantic side runs because the keywords found little; what it
+    finds is answered, under the same filters as the keywords."""
+    config = _plain_config(tmp_path)
+    py = {"id": "FILE:x.py::f", "type": "Function", "metadata": {"name": "f"}}
+    rs = {"id": "FILE:y.rs::g", "type": "Function", "metadata": {"name": "g"}}
+    _write_graph(config, nodes=[py, rs])
+    svc = DescryService(config)
+
+    class Searcher:
+        def __init__(self, graph_path, **kwargs):
+            pass
+
+        def ensure_model(self):
+            pass
+
+        def search(self, query, limit=10, min_score=0.0, keep=None):
+            return [
+                r for r in [(py, 0.9), (rs, 0.8)] if keep is None or r[0]["id"] in keep
+            ]
+
+    svc._semantic_available, svc._SemanticSearcher = True, Searcher
+    data = await svc.search_data(terms, lang=lang)
+    assert ([n["id"] for n in data["results"]], data["method"]) == (found, "hybrid")

{descry_codegraph-0.3.2 → descry_codegraph-0.3.4}/tests/test_query.py

@@ -301,12 +301,16 @@ class TestFindCallPath:
 
         os.unlink(f.name)
 
+    @pytest.mark.parametrize(
+        "target", ["validate_token", "FILE:auth.rs::validate_token"]
+    )
     def test_structured_flow_stops_at_the_target_and_reports_the_path(
-        self, call_path_graph
+        self, call_path_graph, target
     ):
+        """The target is named by name or by node ID."""
         q = GraphQuerier(call_path_graph)
 
-        tree = q.trace_flow_structured("handle_request", target="validate_token")
+        tree = q.trace_flow_structured("handle_request", target=target)
 
         assert tree["path_to_target"] == [
             "handle_request",
@@ -1073,6 +1077,14 @@ class TestLanguageFilter:
     def test_all_and_none_do_not_filter(self, querier, lang):
         assert len(querier.search_docs(["handler"], lang=lang)) == len(self.FILES)
 
+    @pytest.mark.parametrize(
+        ("kind", "found"), [("function", len(FILES)), ("class", 0), ("struct", 0)]
+    )
+    def test_type_keeps_only_that_type(self, querier, kind, found):
+        """A type the graph has none of, or no type descry has, matches
+        nothing, as an unknown language does."""
+        assert len(querier.search_docs(["handler"], symbol_type=kind)) == found
+
 
 class TestCallPathDepthAndOutcome:
     def _chain(self, tmp_path, length, **config):