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

descry_codegraph-1.0.0/CLAUDE.md → descry_codegraph-1.0.1/AGENTS.md

@@ -1,6 +1,6 @@
-# CLAUDE.md
+# AGENTS.md
 
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+This file provides guidance to coding agents when working with code in this repository.
 
 ## Commands
 
@@ -23,7 +23,7 @@ just test tests/test_config.py::TestFromToml::test_from_toml_basic  # 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 (3306 tests pass; a handful more are skipped where the environment lacks their fixture — 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 (3343 tests pass; a handful more are skipped where the environment lacks their fixture — a drop is a regression signal).
 
 Invoke the tool while developing:
 

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

@@ -4,6 +4,18 @@ 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.1] — 2026-10-30
+
+### Fixed
+
+- On macOS, stopping `descry index` (Ctrl-C, `SIGINT`) stops the run as
+  `SIGTERM` and `SIGHUP` do; it reported "Index error: Operation not
+  permitted" and exited 2.
+
+### Changed
+
+- `CLAUDE.md` is `AGENTS.md`.
+
 ## [1.0.0] — 2026-10-29
 
 ### Breaking

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: descry-codegraph
-Version: 1.0.0
+Version: 1.0.1
 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

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

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

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

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

{descry_codegraph-1.0.0 → descry_codegraph-1.0.1}/src/descry/handlers.py

@@ -1058,7 +1058,7 @@ def _kill_process_tree(proc: asyncio.subprocess.Process) -> None:
         )
     else:
         # The child may have exited without the event loop having seen it yet.
-        with contextlib.suppress(ProcessLookupError):
+        with contextlib.suppress(ProcessLookupError, PermissionError):
             os.killpg(proc.pid, signal.SIGKILL)
 
 

{descry_codegraph-1.0.0 → descry_codegraph-1.0.1}/tests/test_backtracking.py

@@ -21,45 +21,80 @@ from descry.generate import CodeGraphBuilder
 
 _GO_FIELD = next(r for r in go_parser._DECLARATIONS if "(?!(?:return" in r.pattern)
 
-# 3,000 characters took seconds to minutes where the time was cubic, and
-# 20,000 seconds where it was quadratic; each now takes milliseconds.
-_RUN = " " * 3000
-_LONG_RUN = " " * 20000
 
+def _seconds(run):
+    """The least CPU time of three calls of `run`."""
+
+    def once():
+        start = time.process_time()
+        run()
+        return time.process_time() - start
+
+    return min(once() for _ in range(3))
+
+
+def assert_linear(run, n):
+    """`run(n)` takes under ten times the CPU time of `run(n // 4)`: time
+    linear in `n` gives four times, quadratic sixteen."""
+    quarter = _seconds(lambda: run(n // 4))
+    assert _seconds(lambda: run(n)) < 10 * max(quarter, 0.05)
 
+
+# 3,000 characters took seconds to minutes where the time was cubic, and
+# 20,000 seconds where it was quadratic.
 @pytest.mark.parametrize(
-    ("find", "text"),
+    ("find", "text", "length"),
     [
-        (_RE_LOCAL_FUNCTION.match, _RUN + "!"),
-        (DartParser.binding_re.search, "const" + _RUN),
-        (java_parser._RE_METHOD.match, "final" + _RUN),
-        (java_parser._RE_FIELD.match, "final" + _RUN),
-        (ts_parser._TS_IMPORT_RE.findall, "import" + _RUN + "x;\n"),
-        (rust_parser._RUST_ARM_RE.search, _RUN + "!"),
-        (java_parser._RE_METHOD.match, "public <T>" + _RUN),
-        (java_parser._RE_METHOD.match, "public @A" + _RUN),
-        (java_parser._RE_ENUM_CONSTANT.match, "A" + _RUN + ")"),
-        (rust_parser._RUST_BINDER_RES[1].findall, "for" + _RUN),
-        (rust_parser._RUST_FOR_RE.search, "    for" + _RUN + "x"),
-        (rust_parser._RUST_IF_LET_RE.search, "while let" + _RUN),
-        (rust_parser._RUST_MATCH_RE.search, "match" + _RUN + "a b"),
-        (ruby_parser._RE_INLINE_BODY.match, "x" + "\r\n" * 1500 + ")"),
-        (dotnet_parser._RE_MEMBER.match, "partial unsafe" + _LONG_RUN + ")"),
-        (dotnet_parser._RE_PARAMETER.search, "scoped readonly" + _LONG_RUN + "x;"),
-        (_GO_FIELD.search, "  chan a" + _LONG_RUN + "x("),
-        (ruby_parser._RE_ALIAS.search, "alias" + _LONG_RUN + ")"),
-        (ruby_parser._RE_MIXIN.match, "  prepend" + _LONG_RUN + "="),
-        (_RE_TYPE.fullmatch, _LONG_RUN + ")"),
-        (java_parser._RE_METHOD.match, "private final a" + _LONG_RUN + "b"),
-        (java_parser._RE_FIELD.match, "public static a" + _LONG_RUN + "b("),
-        (ruby_parser._RE_ENDLESS.match, _LONG_RUN * 3 + "x"),
-        (ruby_parser._RE_INLINE_BODY.match, "end" + "\n" * 60000 + "x"),
-        (dotnet_parser._RE_PRIMARY_CONSTRUCTOR.match, _LONG_RUN * 3 + "x"),
-        (dotnet_parser._RE_PARAMETER.findall, "readonly" + "\t\n " * 20000 + ")"),
-        (_RE_CLOSURE.findall, "\n" * 60000),
-        (ts_parser._TS_IMPORT_RE.findall, "\n" * 60000),
-        (ts_parser._TS_DEFAULT_EXPORT_RE.findall, "\u2028" * 60000),
-        (rust_parser._RUST_USE_RE.findall, "\n" * 60000),
+        (_RE_LOCAL_FUNCTION.match, lambda n: " " * n + "!", 3000),
+        (DartParser.binding_re.search, lambda n: "const" + " " * n, 3000),
+        (java_parser._RE_METHOD.match, lambda n: "final" + " " * n, 3000),
+        (java_parser._RE_FIELD.match, lambda n: "final" + " " * n, 3000),
+        (ts_parser._TS_IMPORT_RE.findall, lambda n: "import" + " " * n + "x;\n", 3000),
+        (rust_parser._RUST_ARM_RE.search, lambda n: " " * n + "!", 3000),
+        (java_parser._RE_METHOD.match, lambda n: "public <T>" + " " * n, 3000),
+        (java_parser._RE_METHOD.match, lambda n: "public @A" + " " * n, 3000),
+        (java_parser._RE_ENUM_CONSTANT.match, lambda n: "A" + " " * n + ")", 3000),
+        (rust_parser._RUST_BINDER_RES[1].findall, lambda n: "for" + " " * n, 3000),
+        (rust_parser._RUST_FOR_RE.search, lambda n: "    for" + " " * n + "x", 3000),
+        (rust_parser._RUST_IF_LET_RE.search, lambda n: "while let" + " " * n, 3000),
+        (rust_parser._RUST_MATCH_RE.search, lambda n: "match" + " " * n + "a b", 3000),
+        (ruby_parser._RE_INLINE_BODY.match, lambda n: "x" + "\r\n" * n + ")", 1500),
+        (
+            dotnet_parser._RE_MEMBER.match,
+            lambda n: "partial unsafe" + " " * n + ")",
+            20000,
+        ),
+        (
+            dotnet_parser._RE_PARAMETER.search,
+            lambda n: "scoped readonly" + " " * n + "x;",
+            20000,
+        ),
+        (_GO_FIELD.search, lambda n: "  chan a" + " " * n + "x(", 20000),
+        (ruby_parser._RE_ALIAS.search, lambda n: "alias" + " " * n + ")", 20000),
+        (ruby_parser._RE_MIXIN.match, lambda n: "  prepend" + " " * n + "=", 20000),
+        (_RE_TYPE.fullmatch, lambda n: " " * n + ")", 20000),
+        (
+            java_parser._RE_METHOD.match,
+            lambda n: "private final a" + " " * n + "b",
+            20000,
+        ),
+        (
+            java_parser._RE_FIELD.match,
+            lambda n: "public static a" + " " * n + "b(",
+            20000,
+        ),
+        (ruby_parser._RE_ENDLESS.match, lambda n: " " * n + "x", 60000),
+        (ruby_parser._RE_INLINE_BODY.match, lambda n: "end" + "\n" * n + "x", 60000),
+        (dotnet_parser._RE_PRIMARY_CONSTRUCTOR.match, lambda n: " " * n + "x", 60000),
+        (
+            dotnet_parser._RE_PARAMETER.findall,
+            lambda n: "readonly" + "\t\n " * n + ")",
+            20000,
+        ),
+        (_RE_CLOSURE.findall, lambda n: "\n" * n, 60000),
+        (ts_parser._TS_IMPORT_RE.findall, lambda n: "\n" * n, 60000),
+        (ts_parser._TS_DEFAULT_EXPORT_RE.findall, lambda n: "\u2028" * n, 60000),
+        (rust_parser._RUST_USE_RE.findall, lambda n: "\n" * n, 60000),
     ],
     ids=[
         "dart-local-function",
@@ -94,34 +129,30 @@ _LONG_RUN = " " * 20000
         "rust-use-blank-lines",
     ],
 )
-def test_a_whitespace_run_is_taken_once(find, text):
-    start = time.process_time()
-
-    find(text)
-
-    assert time.process_time() - start < 1
+def test_a_whitespace_run_is_taken_once(find, text, length):
+    assert_linear(lambda n: find(text(n)), length)
 
 
 @pytest.mark.parametrize(
     ("name", "source", "count"),
     [
-        ("m.js", lambda n: "const b = { a: g() };\n" * n, 20000),
-        ("m.js", lambda n: "let b = 1;\n" + "b = g();\nb.x();\n" * n, 10000),
+        ("m.js", lambda n: "const b = { a: g() };\n" * n, 10000),
+        ("m.js", lambda n: "let b = 1;\n" + "b = g();\nb.x();\n" * n, 5000),
         (
             "m.js",
             lambda n: (
                 "function f(xs) {\n" + "  for (const x of xs) { x.a(); }\n" * n + "}\n"
             ),
-            15000,
+            7500,
         ),
-        ("m.rb", lambda n: "b = 2\n" * n, 20000),
-        ("m.rb", lambda n: "a = []\n" + "a <<-b\n" * n, 60000),
-        ("m.dart", lambda n: "void main() {\n" + "  var b = 2;\n" * n + "}\n", 20000),
-        ("m.py", lambda n: "def f():\n" + "    b = B()\n    b.x()\n" * n, 20000),
+        ("m.rb", lambda n: "b = 2\n" * n, 10000),
+        ("m.rb", lambda n: "a = []\n" + "a <<-b\n" * n, 30000),
+        ("m.dart", lambda n: "void main() {\n" + "  var b = 2;\n" * n + "}\n", 10000),
+        ("m.py", lambda n: "def f():\n" + "    b = B()\n    b.x()\n" * n, 10000),
         (
             "m.py",
             lambda n: "def f(xs):\n" + "    for x in xs:\n        x.a()\n" * n,
-            10000,
+            5000,
         ),
         (
             "M.java",
@@ -130,7 +161,7 @@ def test_a_whitespace_run_is_taken_once(find, text):
                 + "    B b = new B();\n    b.x();\n" * n
                 + "  }\n}\n"
             ),
-            10000,
+            5000,
         ),
         (
             "M.cs",
@@ -139,14 +170,14 @@ def test_a_whitespace_run_is_taken_once(find, text):
                 + "    var b = new B();\n    b.X();\n" * n
                 + "  }\n}\n"
             ),
-            8000,
+            4000,
         ),
         (
             "M.cs",
             lambda n: "".join(
                 f"class C{i} {{ int M() {{ return {i}; }} }}\n" for i in range(n)
             ),
-            3000,
+            1500,
         ),
         (
             "m.go",
@@ -156,7 +187,7 @@ def test_a_whitespace_run_is_taken_once(find, text):
                 * n
                 + "\treturn nil\n}\n"
             ),
-            10000,
+            5000,
         ),
         (
             "m.php",
@@ -165,14 +196,14 @@ def test_a_whitespace_run_is_taken_once(find, text):
                 + "    foreach ($xs as $x) { $x->a(); }\n" * n
                 + "}\n"
             ),
-            8000,
+            4000,
         ),
         (
             "src/lib.rs",
             lambda n: "".join(
                 f"fn f{i}<T: Clone>(a: T) -> T {{ a.clone() }}\n" for i in range(n)
             ),
-            12000,
+            6000,
         ),
         (
             "m.js",
@@ -182,7 +213,7 @@ def test_a_whitespace_run_is_taken_once(find, text):
                 * n
                 + "}\n"
             ),
-            5000,
+            2500,
         ),
         (
             "src/lib.rs",
@@ -191,7 +222,7 @@ def test_a_whitespace_run_is_taken_once(find, text):
                 + "    match v { Some(b) => b.a(), None => () }\n" * n
                 + "}\n"
             ),
-            10000,
+            5000,
         ),
     ],
     ids=[
@@ -216,22 +247,18 @@ def test_a_whitespace_run_is_taken_once(find, text):
 def test_a_repeated_line_is_read_in_linear_time(name, source, count, tmp_path):
     """A line that binds a name again, loops over it, matches it, or
     declares a type or a generic function costs the same time however many
-    came before it: four times the lines take about four times as long,
-    where they took sixteen times, minutes in all. The ratio, not a time,
-    is checked, so a slow machine does not fail it."""
+    came before it, where four times the lines took sixteen times as long,
+    minutes in all."""
 
     def reading(lines):
         root = tmp_path / str(lines)
         (root / name).parent.mkdir(parents=True, exist_ok=True)
         (root / name).write_text(source(lines))
-        start = time.process_time()
         builder = CodeGraphBuilder(root)
         builder.process_directory()
         builder.resolve_references()
-        return time.process_time() - start
 
-    quarter = reading(count // 4)
-    assert reading(count) < 8 * max(quarter, 0.05)
+    assert_linear(reading, count)
 
 
 def test_the_patterns_still_match_source():

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

@@ -22,6 +22,7 @@ from descry.python_parser import PythonParser
 from descry.resolver import CallResolver
 from descry.rust_parser import RustParser
 from descry.ts_parser import TSParser
+from tests.test_backtracking import assert_linear
 
 
 class TestPythonParser:
@@ -3168,13 +3169,18 @@ class TestPythonCallResolution:
 
     def test_many_branches_merge_in_time_linear_in_the_code(self, tmp_path):
         """Merging the ways of many branches costs time in the bindings they
-        hold, not in every name the file declares: four thousand `if`s are
-        parsed in seconds."""
-        source = "def f(c):\n" + "".join(f"    if c: x{i} = 1\n" for i in range(4000))
-        (tmp_path / "m.py").write_text(source)
-        started = time.process_time()
-        CodeGraphBuilder(tmp_path).process_directory()
-        assert time.process_time() - started < 3
+        hold, not in every name the file declares."""
+
+        def parse(n):
+            _index(
+                tmp_path / str(n),
+                {
+                    "m.py": "def f(c):\n"
+                    + "".join(f"    if c: x{i} = 1\n" for i in range(n))
+                },
+            )
+
+        assert_linear(parse, 4000)
 
     def test_a_break_in_a_match_case_skips_the_else(self, tmp_path):
         """A `break` inside a `case` body skips the loop's `else`, so `x`
@@ -14989,35 +14995,37 @@ class TestTypeScriptCallResolution:
 
     def test_scopes_are_read_in_time_linear_in_the_code(self, tmp_path):
         """A line of thousands of assignments in one sequence, and of
-        thousands of nested labelled blocks, is read in a few seconds: no
-        token is read back over once per assignment after it."""
-        count = 2000
-        line = (
-            "function f(){var a;"
-            + ",".join(["a=1"] * count)
-            + ";"
-            + "".join(f"l{i}:{{" for i in range(count))
-            + "a=2;"
-            + "}" * count
-            + "}\n"
-        )
-        started = time.process_time()
-        builder = _index(tmp_path, {"a.js": line})
-        assert time.process_time() - started < 6
-        assert any(n["id"] == "FILE:a.js::f" for n in builder.nodes)
+        thousands of nested labelled blocks, is read in time linear in its
+        length: no token is read back over once per assignment after it."""
+
+        def index(n):
+            line = (
+                "function f(){var a;"
+                + ",".join(["a=1"] * n)
+                + ";"
+                + "".join(f"l{i}:{{" for i in range(n))
+                + "a=2;"
+                + "}" * n
+                + "}\n"
+            )
+            return _index(tmp_path / str(n), {"a.js": line})
+
+        assert_linear(index, 2000)
+        assert any(n["id"] == "FILE:a.js::f" for n in index(2000).nodes)
 
     def test_the_bindings_of_one_name_are_read_in_time_linear_in_the_code(
         self, tmp_path
     ):
         """A line of six thousand assignments of one name in one function
-        is indexed in seconds: a read of the name looks only at the
-        bindings that can be in scope where it is read."""
-        count = 6000
-        line = "function f(){var a;" + "a=1," * count + "}\n"
-        started = time.process_time()
-        builder = _index(tmp_path, {"a.js": line})
-        assert time.process_time() - started < 3
-        assert any(n["id"] == "FILE:a.js::f" for n in builder.nodes)
+        is indexed in time linear in its length: a read of the name looks
+        only at the bindings that can be in scope where it is read."""
+
+        def index(n):
+            line = "function f(){var a;" + "a=1," * n + "}\n"
+            return _index(tmp_path / str(n), {"a.js": line})
+
+        assert_linear(index, 6000)
+        assert any(n["id"] == "FILE:a.js::f" for n in index(6000).nodes)
 
     def test_a_block_starts_wherever_a_statement_does(self, tmp_path):
         """A `{` is a block after a label's, a `case`'s or `default`'s `:`,

{descry_codegraph-1.0.0 → descry_codegraph-1.0.1}/tests/test_ground_truth.py

@@ -52,7 +52,10 @@ def services(tmp_path_factory):
                     project_root=root, enable_scip=False, enable_embeddings=False
                 )
             )
-            asyncio.run(svc.index())
+            with pytest.MonkeyPatch.context() as mp:
+                mp.setenv("DESCRY_NO_SCIP", "1")
+                mp.setenv("DESCRY_NO_EMBEDDINGS", "1")
+                asyncio.run(svc.index())
             built[language] = svc
         return built[language]
 

{descry_codegraph-1.0.0 → descry_codegraph-1.0.1}/tests/test_web_server.py

@@ -381,9 +381,9 @@ class TestSourceRaces:
             if str(path).endswith("pipe.txt") and not writers:
                 target.unlink()
                 os.mkfifo(target)
-                # A writer with a full sample pending, so a blocking open and
-                # read of the FIFO return instead of hanging the test.
-                writers.append(real_open(target, os.O_RDWR))
+                # A writer with data pending, so a blocking open and read of
+                # the FIFO return instead of hanging the test.
+                writers.append(real_open(target, os.O_RDWR | os.O_NONBLOCK))
                 os.write(writers[0], b"x" * 16384)
             return real_open(path, flags, *args, **kwargs)
 
@@ -483,7 +483,7 @@ class TestLoopbackHostFlag:
 class TestServiceDelegation:
     """The web layer must not carry its own copy of DescryService's logic.
 
-    CLAUDE.md: "DescryService owns all business logic. cli.py, mcp_server.py
+    AGENTS.md: "DescryService owns all business logic. cli.py, mcp_server.py
     and web/server.py are thin wrappers."
     """