descry-codegraph 1.0.1__tar.gz → 1.0.2__tar.gz

{descry_codegraph-1.0.1 → descry_codegraph-1.0.2}/CHANGELOG.md

@@ -4,6 +4,26 @@ All notable changes to Descry will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres to [semver](https://semver.org/) from 1.0.0.
 
+## [1.0.2] — 2026-10-31
+
+### Fixed
+
+- Rust glob re-exports (`pub use m::*`) that reach a module by several
+  routes, or lead back round a cycle, no longer make indexing exponential:
+  each name a glob brings, and each type alias, is looked up once per
+  file.
+- Rust: `<Self>::f(x)` is read as `Self::f(x)`; it, and a crate-root path
+  `::f(x)` with an argument of a project type, stopped the index.
+- Rust: indexing a nested `vec![vec![..]; n]` twice stopped the index.
+- Rust: a `static` or `const` in a `quote!` template, its type written
+  with `#` interpolations, stopped the index.
+- MCP: arguments a tool cannot read are refused naming what is wrong with
+  each (`terms: Field required`), not the field alone.
+- CLI: without a terminal on stderr, loading the embedding model prints no
+  progress bars or Hugging Face Hub notices; `HF_HUB_DISABLE_PROGRESS_BARS`,
+  `HF_HUB_VERBOSITY` and `TRANSFORMERS_VERBOSITY` set by the user are kept.
+- README: `[timeouts] index_minutes = 0` is no time limit.
+
 ## [1.0.1] — 2026-10-30
 
 ### Fixed

{descry_codegraph-1.0.1 → descry_codegraph-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: descry-codegraph
-Version: 1.0.1
+Version: 1.0.2
 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
@@ -308,7 +308,7 @@ timeout = 30
 scip_minutes = 30      # per indexer; 0 = unlimited
 embedding_seconds = 60 # MCP and web answer `loading` past it; the CLI waits
 query_ms = 4000         # 0 = no time limit
-index_minutes = 30     # Timeout for `descry index` subprocess
+index_minutes = 30     # Timeout for `descry index` subprocess; 0 = unlimited
 
 [query]
 max_depth = 3

{descry_codegraph-1.0.1 → descry_codegraph-1.0.2}/README.md

@@ -247,7 +247,7 @@ timeout = 30
 scip_minutes = 30      # per indexer; 0 = unlimited
 embedding_seconds = 60 # MCP and web answer `loading` past it; the CLI waits
 query_ms = 4000         # 0 = no time limit
-index_minutes = 30     # Timeout for `descry index` subprocess
+index_minutes = 30     # Timeout for `descry index` subprocess; 0 = unlimited
 
 [query]
 max_depth = 3

{descry_codegraph-1.0.1 → descry_codegraph-1.0.2}/pyproject.toml

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

{descry_codegraph-1.0.1 → descry_codegraph-1.0.2}/src/descry/__init__.py

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

{descry_codegraph-1.0.1 → descry_codegraph-1.0.2}/src/descry/cli.py

@@ -11,6 +11,7 @@ Usage:
 import argparse
 import asyncio
 import json
+import os
 import sys
 
 from descry._answers import fail
@@ -516,6 +517,14 @@ def build_parser():
 
 def main():
     write_utf8()
+    if not sys.stderr.isatty():
+        # Scripted use: no model-loading progress bars or Hub notices.
+        for name, value in (
+            ("HF_HUB_DISABLE_PROGRESS_BARS", "1"),
+            ("HF_HUB_VERBOSITY", "error"),
+            ("TRANSFORMERS_VERBOSITY", "error"),
+        ):
+            os.environ.setdefault(name, value)
     parser = build_parser()
     args = parser.parse_args()
 

{descry_codegraph-1.0.1 → descry_codegraph-1.0.2}/src/descry/mcp_server.py

@@ -115,13 +115,13 @@ class _Server(MCPServer):
             if isinstance(exc.__cause__, ValidationError):
                 fields = sorted(
                     {
-                        ".".join(str(part) for part in err["loc"])
+                        f"{'.'.join(str(part) for part in err['loc'])}: {err['msg']}"
                         for err in exc.__cause__.errors()
                     }
                 )
                 answer = fail(
                     "invalid",
-                    f"Invalid arguments for {name}: {', '.join(fields)}.",
+                    f"Invalid arguments for {name}: {'; '.join(fields)}.",
                 )
                 return _answered(json.dumps(public(answer), indent=2), answer)
             raise

{descry_codegraph-1.0.1 → descry_codegraph-1.0.2}/src/descry/resolver.py

@@ -1297,7 +1297,9 @@ class CallResolver:
         # signature a call of it is of
         "overloads",
         "reaches",  # file ID -> the files its includes reach (C/C++)
+        "rust_aliases",  # (Rust module, name) -> see _alias_in
         "rust_in_scope",  # Rust scope ID -> the modules named there
+        "rust_used",  # (Rust module, name) -> see _rust_used
         "rust_uses",  # Rust scope ID -> what the `use`s in force bind
         "shared_declaration",  # candidate node IDs -> node ID or None
         # Language -> the last name segments of the types and functions its
@@ -1327,6 +1329,8 @@ class CallResolver:
         "_forwarding",
         "open_aliases",
         "standard",
+        "_rust_walked",
+        "_rust_begun",
     )
 
     def begin_file(self):
@@ -1593,6 +1597,9 @@ class CallResolver:
             builder.rust_mods, files
         )
         self._importing = set()  # (scope ID, name) of the Rust `use`s being read
+        self._rust_cuts = 0  # times a Rust cycle guard stopped a walk
+        self._rust_walked = {}  # see _rust_keep
+        self._rust_begun = []  # see _rust_recall
         # A module is importable by its path below its topmost package and,
         # through namespace packages, by any longer path no other module owns.
         for top, parts, file_id in py_files:
@@ -2104,10 +2111,11 @@ class CallResolver:
         elif (
             verdict == (None, _EXTERNAL)
             and self._path_call
+            and (split := _split_callee(callee))[0]
             and (owner := self._receiver_type())
         ):
             # An outside trait's path: the receiver's project impl of it.
-            path, name = _split_callee(callee)
+            path, name = split
             own = [
                 m
                 for m in self._rust_trait_methods(owner, name, path[-1])
@@ -3124,7 +3132,9 @@ class CallResolver:
                 (target,),
             )
             found = None
-            if (scope_id, name) not in self._importing:
+            if (scope_id, name) in self._importing:
+                self._rust_cuts += 1
+            else:
                 # A `use` may lead back to itself through the module tree.
                 self._importing.add((scope_id, name))
                 try:
@@ -3357,11 +3367,42 @@ class CallResolver:
         ]
         return defined or found
 
+    def _rust_recall(self, memo, key, seen):
+        """``[value]`` kept for the Rust walk through `use`s and globs for
+        ``key`` whose cycle guard holds ``seen`` (see `_rust_keep`); else
+        None, and the walk is begun."""
+        if key in memo:
+            return [memo[key]]
+        if seen and key in self._rust_walked:
+            self._rust_cuts += 1
+            return [self._rust_walked[key]]
+        self._rust_begun.append((self._rust_cuts, self._rust_walked))
+        if not seen:
+            self._rust_walked = {}
+        return None
+
+    def _rust_keep(self, memo, key, seen, found):
+        """``found``, what the walk `_rust_recall` began gives: kept in
+        ``memo`` for the file; where a cycle guard cut it short, only until
+        the walk that began with no ``seen`` ends. A module that globs reach
+        by several routes is then walked once."""
+        cuts, outer = self._rust_begun.pop()
+        if not seen:
+            self._rust_walked = outer
+        if self._rust_cuts == cuts:
+            memo[key] = found
+        elif seen:
+            self._rust_walked[key] = found
+        return found
+
     def _rust_used(self, module, segment, seen):
         """What a `use` of the Rust module ``module`` binds ``segment`` to,
         a path from the module or from a crate, else what each glob `use`
         of the module's own does: IDs, ``"external"`` where one leads
         outside the project. ``seen`` as `_rust_path`'s."""
+        key = (module, segment)
+        if kept := self._rust_recall(self.rust_used, key, seen):
+            return kept[0]
         uses = self._uses(module)
         alternatives = self.builder.rust_use_alternatives.get((module, segment))
         written = [uses[segment]] if segment in uses else []
@@ -3376,16 +3417,18 @@ class CallResolver:
             if segment in uses and not self._rust_rooted(target, module):
                 held = self._imported(segment, module)
             elif self._rust_rooted(target, module):
-                if (module, segment) not in seen:
-                    followed = seen | {(module, segment)}
-                    held = self._rust_path(target.split("::"), module, followed)
+                if key in seen:
+                    self._rust_cuts += 1
+                else:
+                    held = self._rust_path(target.split("::"), module, seen | {key})
             else:
                 # A glob of another crate's module may bring the name.
                 held = _EXTERNAL
             if held == _EXTERNAL:
-                return _EXTERNAL
+                hits = _EXTERNAL
+                break
             hits += held or []
-        return hits
+        return self._rust_keep(self.rust_used, key, seen, hits)
 
     def _rust_library(self, name, scope_id):
         """The root of the library of the project crate ``name`` written in
@@ -4820,7 +4863,7 @@ class CallResolver:
                     value = self._called(member, value if len(value) > 2 else value[1])
                     value = value[1] if value and value[0] == "pointer" else value
                 continue
-            if step == "[]" and isinstance(value, tuple):
+            if step == "[]" and isinstance(value, tuple) and value[0] != "literal":
                 # A subscript gives what the type's `operator[]` returns, in
                 # Rust its `Index` impl's `Output`, the element an iterator
                 # gives where the index decides it: by the data for a
@@ -8152,17 +8195,24 @@ class CallResolver:
         found = self.builder.rust_alias_types.get((module, name))
         if found:
             return module, name, _rust_declared(found)
+        key = (module, name)
+        if kept := self._rust_recall(self.rust_aliases, key, seen):
+            return kept[0]
         uses = self._uses(module)
         written = [uses[name]] if name in uses else []
         written = written or [
             f"{path[:-1]}{name}" for path in uses.values() if path[-3:] == "::*"
         ]
+        hit = None
         for target in written:
             *qualifier, leaf = target.split("::")
             if qualifier and self._rust_child(module, qualifier[0]):
                 qualifier = ["self", *qualifier]
             path = "::".join([*qualifier, leaf])
-            if not qualifier or (module, path) in seen:
+            if not qualifier:
+                continue
+            if (module, path) in seen:
+                self._rust_cuts += 1
                 continue
             if not self._rust_rooted(path, module):
                 continue
@@ -8170,8 +8220,10 @@ class CallResolver:
             for scope in held if isinstance(held, list) else ():
                 hit = self._alias_in(scope, leaf, seen | {(module, path)})
                 if hit:
-                    return hit
-        return None
+                    break
+            if hit:
+                break
+        return self._rust_keep(self.rust_aliases, key, seen, hit)
 
     def _alias_value(self, alias, written, scope_id, receiver):
         """Value of the type ``written`` in ``scope_id`` that names the Rust

{descry_codegraph-1.0.1 → descry_codegraph-1.0.2}/src/descry/rust_parser.py

@@ -50,7 +50,7 @@ _RUST_STRING_LET_RE = re.compile(
 
 _RUST_CONST_RE = re.compile(
     r"\b(?:const|static)\s+(?:mut\s+)?(?P<name>[A-Z][A-Z0-9_]*)\s*:\s*"
-    r"(?P<type>[^=;().]+?)\s*="
+    r"(?P<type>[^=;().#]+?)\s*="
 )
 
 
@@ -1960,6 +1960,10 @@ class RustParser(BaseParser):
                     # with its arguments.
                     typed = re.fullmatch(r"(\w+)::<(.+)>::(\w+)", callee)
                     typed = typed and f"{typed[1]}<{typed[2]}>.{typed[3]}"
+                    # `<Self>::f` is `Self::f`.
+                    closed = callee[:1] == "<" and _angle_end(callee, 0)
+                    if closed and callee[closed + 1 : closed + 3] == "::":
+                        callee = callee[1:closed] + callee[closed + 1 :]
                     # `parse::<T>` calls `parse`; the type arguments are the
                     # call site's, not part of the callee's name.
                     callee = _strip_generics(callee)

{descry_codegraph-1.0.1 → descry_codegraph-1.0.2}/tests/test_cli.py

@@ -65,6 +65,29 @@ class TestCliNoCommand:
         assert result.returncode == 1
 
 
+class TestCliHubOutput:
+    _NAMES = (
+        "HF_HUB_DISABLE_PROGRESS_BARS",
+        "HF_HUB_VERBOSITY",
+        "TRANSFORMERS_VERBOSITY",
+    )
+
+    @pytest.mark.parametrize("terminal", [False, True])
+    def test_scripted_use_quiets_model_loading(self, monkeypatch, terminal):
+        """Without a terminal on stderr, model loading shows no progress bars
+        or Hub notices; a value the user set is kept."""
+        for name in self._NAMES:
+            monkeypatch.delenv(name, raising=False)
+        monkeypatch.setenv("HF_HUB_VERBOSITY", "info")
+        monkeypatch.setattr(sys.stderr, "isatty", lambda: terminal)
+        monkeypatch.setattr(sys, "argv", ["descry"])
+        with pytest.raises(SystemExit):
+            cli.main()
+        assert [os.environ.get(name) for name in self._NAMES] == (
+            [None, "info", None] if terminal else ["1", "info", "error"]
+        )
+
+
 class TestCliArguments:
     @pytest.mark.parametrize(
         "args", [["callers", "x", "--limit", "ten"], ["search", "x", "--frob", "1"]]

{descry_codegraph-1.0.1 → descry_codegraph-1.0.2}/tests/test_generate.py

@@ -4398,6 +4398,99 @@ class TestRustCallResolution:
             "FILE:src/lib.rs::Vec2::new"
         ]
 
+    def test_qualified_self_path_is_the_type_path(self, tmp_path):
+        """`<Self>::make()` and `<W>::make()` call `W::make`."""
+        builder = _index(
+            tmp_path,
+            {
+                "src/lib.rs": """
+                pub struct W;
+                impl W {
+                    pub fn make() -> W {
+                        W
+                    }
+                    pub fn both() {
+                        <Self>::make();
+                        <W>::make();
+                    }
+                }
+                """
+            },
+        )
+        assert _calls(builder, "FILE:src/lib.rs::W::both") == [
+            "FILE:src/lib.rs::W::make",
+            "FILE:src/lib.rs::W::make",
+        ]
+
+    def test_crate_root_path_on_project_argument_indexes(self, tmp_path):
+        """`::try_from(x)`, a Rust 2015 crate-root path, names no trait: an
+        argument of a project type does not make it one."""
+        builder = _index(
+            tmp_path,
+            {
+                "src/lib.rs": """
+                pub struct Sl;
+                pub struct Arr;
+                impl TryFrom<&Sl> for Arr {
+                    type Error = ();
+                    fn try_from(value: &Sl) -> Result<Self, ()> {
+                        Err(())
+                    }
+                }
+                impl TryFrom<&mut Sl> for Arr {
+                    type Error = ();
+                    fn try_from(value: &mut Sl) -> Result<Self, ()> {
+                        ::try_from(&*value)
+                    }
+                }
+                """
+            },
+        )
+        assert _calls(builder, "FILE:src/lib.rs::Arr::try_from#2") == []
+
+    def test_index_of_nested_vec_literal_indexes(self, tmp_path):
+        """`data[i][j].go()` on `vec![vec![P; r]; c]` reads the inner
+        literal's element, not a member of the outer literal."""
+        builder = _index(
+            tmp_path,
+            {
+                "src/lib.rs": """
+                #[derive(Clone)]
+                pub struct P;
+                impl P {
+                    pub fn go(&self) {}
+                }
+                pub fn grid(r: usize, c: usize) {
+                    let data = vec![vec![P; r]; c];
+                    data[0][0].go();
+                }
+                """
+            },
+        )
+        assert _calls(builder, "FILE:src/lib.rs::grid") == ["REF:go"]
+
+    def test_static_in_quote_template_has_no_type(self, tmp_path):
+        """`static CELL: #path::#ty = ...;` in a `quote!` template writes no
+        type: `#` interpolates a variable."""
+        builder = _index(
+            tmp_path,
+            {
+                "src/lib.rs": """
+                pub struct Cell;
+                impl Cell {
+                    pub fn get_or_set(&self) {}
+                }
+                pub fn gen(p: u8, cell_type: u8) {
+                    quote! {
+                        static CELL: #p::utility::#cell_type = #p::utility::#cell_type::new();
+                        CELL.get_or_set(|| {});
+                    }
+                }
+                """
+            },
+        )
+        assert _calls(builder, "FILE:src/lib.rs::gen") == ["REF:CELL.get_or_set"]
+
     def test_a_name_only_hit_does_not_type_its_result(self, tmp_path):
         """`m.start()` where `m` is what `find_at` yields: `find_at` fits
         by name only on a receiver no project type owns, so what it

{descry_codegraph-1.0.1 → descry_codegraph-1.0.2}/tests/test_mcp.py

@@ -294,7 +294,7 @@ class TestLifespan:
             result = await mod.mcp.call_tool("descry_callees", {"symbol": 42})
             assert result.is_error
             assert result.structured_content == {
-                "error": "Invalid arguments for descry_callees: symbol.",
+                "error": "Invalid arguments for descry_callees: symbol: Input should be a valid string.",
                 "reason": "invalid",
             }