descry-codegraph 0.1.0__tar.gz → 0.1.1__tar.gz

{descry_codegraph-0.1.0 → descry_codegraph-0.1.1}/CHANGELOG.md

@@ -4,6 +4,44 @@ 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 pre-1.0 semver (minor-version bumps may include breaking changes; see README versioning stance).
 
+## [0.1.1] — 2026-04-17
+
+Patch release focused on making cross-language tracing actually configurable,
+plus a round of dead-code cleanup. No breaking changes.
+
+### Fixed
+
+- **Cross-language tracing is now configurable from `.descry.toml`.** The
+  `DescryConfig.openapi_path` field existed in 0.1.0 but had no TOML loader
+  and the web `/api/cross-lang` handler hardcoded `public/api/latest.json`,
+  so custom spec locations silently did nothing. Added a `[cross_lang]`
+  section with `openapi_path`, `backend_handler_patterns`,
+  `frontend_api_patterns`, and `api_prefixes` keys. Web and CLI/MCP now
+  both honour the config and pass all four through to `CrossLangTracer`.
+- `[cross_lang] openapi_path` is containment-checked against the project
+  root; a crafted `.descry.toml` cannot point the indexer at files outside
+  the configured project.
+
+### Removed
+
+Dead code with no call sites anywhere in the tree was pruned:
+
+- `DescryConfig.project_markers` (auto-detect used a module constant).
+- `DescryConfig.use_tree_sitter_ts` (scaffolding field with no consumer).
+- `descry.query.MAX_INLINE_THRESHOLD` constant.
+- `CrossLangTracer.endpoint_to_node_id()` and module-level
+  `_create_cross_lang_edges()` helper.
+- `SemanticSearcher._find_similar()` (distinct from
+  `GraphQuerier._find_similar_nodes`, which remains).
+- `descry.ast_grep.extract_imports_typescript_batch()`.
+- `ScipIndex.get_definition_location()` and `get_symbol_info()`.
+- `TypeScriptSymbolTable.file_dir` attribute.
+- `DescryService._clear_dedup_cache()` (superseded by `reset_caches()` in
+  the 0.1.0 hardening sweep).
+
+A `vulture --min-confidence 80` sweep on `src/descry/` now reports zero
+findings outside generated protobuf code.
+
 ## [0.1.0] — 2026-04-16
 
 Initial public PyPI release. Descry is a polyglot codebase knowledge graph toolkit with three interfaces: CLI (`descry`), MCP server (`descry-mcp`), and local web UI (`descry-web`).

{descry_codegraph-0.1.0 → descry_codegraph-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: descry-codegraph
-Version: 0.1.0
+Version: 0.1.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-0.1.0 → descry_codegraph-0.1.1}/pyproject.toml

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

{descry_codegraph-0.1.0 → descry_codegraph-0.1.1}/src/descry/ast_grep.py

@@ -354,29 +354,3 @@ def extract_imports_typescript(file_path: str) -> dict:
             continue
 
     return result
-
-
-def extract_imports_typescript_batch(file_paths: list) -> dict:
-    """Extract imports from multiple TypeScript files efficiently.
-
-    Processes files individually but caches results for repeated calls.
-
-    Args:
-        file_paths: List of file paths to process
-
-    Returns:
-        Dict mapping file paths to their import data:
-        {
-            "path/to/file.ts": {
-                "imports": {"name": ("module", "type")},
-                "namespaces": {"alias": "module"},
-            }
-        }
-    """
-    results = {}
-    for file_path in file_paths:
-        try:
-            results[file_path] = extract_imports_typescript(file_path)
-        except Exception:
-            results[file_path] = {"imports": {}, "namespaces": {}}
-    return results

{descry_codegraph-0.1.0 → descry_codegraph-0.1.1}/src/descry/cross_lang.py

@@ -185,7 +185,7 @@ class CrossLangTracer:
             return self.path_to_operation[key]["operationId"]
 
         # Try pattern matching for paths with IDs
-        for pattern_method, template_path, pattern, info in self.endpoint_patterns:
+        for pattern_method, _, pattern, info in self.endpoint_patterns:
             if pattern_method == method_upper and pattern.match(path):
                 return info["operationId"]
 
@@ -197,21 +197,6 @@ class CrossLangTracer:
 
         return None
 
-    def endpoint_to_node_id(self, method: str, path: str) -> Optional[str]:
-        """Find the graph node ID for a backend handler.
-
-        Args:
-            method: HTTP method
-            path: API path
-
-        Returns:
-            Full node ID (e.g., "FILE:backend/src/routes/actions/handlers.rs::list_actions")
-        """
-        op_id = self.endpoint_to_handler(method, path)
-        if op_id:
-            return self.operation_to_handler.get(op_id)
-        return None
-
     def get_handler_info(self, method: str, path: str) -> Optional[dict]:
         """Get full information about an endpoint's handler.
 
@@ -227,7 +212,7 @@ class CrossLangTracer:
             return info
 
         # Try pattern matching
-        for pattern_method, template_path, pattern, info in self.endpoint_patterns:
+        for pattern_method, _, pattern, info in self.endpoint_patterns:
             if pattern_method == method_upper and pattern.match(path):
                 result = info.copy()
                 result["node_id"] = self.operation_to_handler.get(info["operationId"])
@@ -349,43 +334,6 @@ class CrossLangTracer:
         }
 
 
-def _create_cross_lang_edges(
-    graph_data: dict,
-    openapi_path: str,
-) -> list[dict]:
-    """Create CALLS_API edges linking frontend to backend handlers.
-
-    This can be used during graph generation to add cross-language edges.
-
-    Args:
-        graph_data: Current graph data (nodes and edges)
-        openapi_path: Path to OpenAPI spec
-
-    Returns:
-        List of new edges to add
-    """
-    tracer = CrossLangTracer(openapi_path)
-    api_calls = tracer.find_ts_api_calls(graph_data)
-
-    edges = []
-    for call in api_calls:
-        if call.get("rust_node_id"):
-            edges.append(
-                {
-                    "source": call["ts_node_id"],
-                    "target": call["rust_node_id"],
-                    "relation": "CALLS_API",
-                    "metadata": {
-                        "endpoint": call["inferred_endpoint"],
-                        "method": call["inferred_method"],
-                        "handler": call["rust_handler"],
-                    },
-                }
-            )
-
-    return edges
-
-
 if __name__ == "__main__":
     # Generic stats-only smoke test. Prints OpenAPI + graph linkage stats.
     import sys

{descry_codegraph-0.1.0 → descry_codegraph-0.1.1}/src/descry/embeddings.py

@@ -441,47 +441,6 @@ class SemanticSearcher:
         results.sort(key=lambda x: x[1], reverse=True)
         return results[:limit]
 
-    def _find_similar(self, node_id: str, limit: int = 5) -> list:
-        """Find nodes semantically similar to a given node.
-
-        Args:
-            node_id: The node ID to find similar nodes for
-            limit: Maximum number of results
-
-        Returns:
-            List of (node, score) tuples sorted by similarity
-        """
-        # Find the node index
-        node_idx = None
-        for i, node in enumerate(self.nodes):
-            if node["id"] == node_id:
-                node_idx = i
-                break
-
-        if node_idx is None:
-            return []
-
-        # Use that node's embedding as query
-        node_embedding = self.embeddings[node_idx]
-
-        # Compute similarities
-        similarities = np.dot(self.embeddings, node_embedding) / (
-            np.linalg.norm(self.embeddings, axis=1) * np.linalg.norm(node_embedding)
-        )
-
-        # Get top results (excluding the query node itself)
-        top_indices = np.argsort(similarities)[::-1]
-        results = []
-        for idx in top_indices:
-            if idx == node_idx:
-                continue
-            score = float(similarities[idx])
-            results.append((self.nodes[idx], score))
-            if len(results) >= limit:
-                break
-
-        return results
-
 
 # Convenience function for one-off searches (with thread safety)
 _cached_searcher = None

{descry_codegraph-0.1.0 → descry_codegraph-0.1.1}/src/descry/generate.py

@@ -1399,7 +1399,6 @@ class TypeScriptSymbolTable:
             project_root: Root directory of the project
         """
         self.file_path = file_path
-        self.file_dir = os.path.dirname(file_path)
         self.project_root = project_root
 
         # local_name -> (module_path, import_type)

{descry_codegraph-0.1.0 → descry_codegraph-0.1.1}/src/descry/handlers.py

@@ -174,14 +174,7 @@ class DescryConfig:
     max_stale_hours: float = 24
     enable_scip: bool = True
     enable_embeddings: bool = True
-    # Opt-in: use tree-sitter for TS/TSX/JS first-pass parsing. Requires
-    # descry-codegraph[ast]. Falls back to regex per-file when the grammar
-    # hits errors or the extra isn't installed.
-    use_tree_sitter_ts: bool = False
     openapi_path: Path | None = None
-    project_markers: list[str] = field(
-        default_factory=lambda: list(_DEFAULT_PROJECT_MARKERS)
-    )
     backend_handler_patterns: list[str] = field(default_factory=list)
     frontend_api_patterns: list[str] = field(default_factory=list)
     api_prefixes: list[str] = field(default_factory=lambda: list(_DEFAULT_API_PREFIXES))
@@ -316,8 +309,6 @@ class DescryConfig:
             self.enable_scip = features["enable_scip"]
         if "enable_embeddings" in features:
             self.enable_embeddings = features["enable_embeddings"]
-        if "use_tree_sitter_ts" in features:
-            self.use_tree_sitter_ts = features["use_tree_sitter_ts"]
 
         # [embeddings]
         embeddings = data.get("embeddings", {})
@@ -388,6 +379,41 @@ class DescryConfig:
         if "skip_crates" in scip:
             self.scip_skip_crates = scip["skip_crates"]
 
+        # [cross_lang]
+        cross_lang = data.get("cross_lang", {})
+        if "backend_handler_patterns" in cross_lang:
+            patterns = cross_lang["backend_handler_patterns"]
+            if isinstance(patterns, list):
+                self.backend_handler_patterns = [str(p) for p in patterns]
+        if "frontend_api_patterns" in cross_lang:
+            patterns = cross_lang["frontend_api_patterns"]
+            if isinstance(patterns, list):
+                self.frontend_api_patterns = [str(p) for p in patterns]
+        if "api_prefixes" in cross_lang:
+            prefixes = cross_lang["api_prefixes"]
+            if isinstance(prefixes, list):
+                self.api_prefixes = [str(p) for p in prefixes]
+        if "openapi_path" in cross_lang:
+            raw = cross_lang["openapi_path"]
+            if isinstance(raw, str) and raw:
+                candidate = Path(raw)
+                if not candidate.is_absolute():
+                    candidate = self.project_root / candidate
+                # Containment check: keep the spec inside project_root so a
+                # crafted .descry.toml can't point descry at arbitrary files.
+                try:
+                    resolved = candidate.resolve(strict=False)
+                    root = self.project_root.resolve()
+                    if resolved == root or root in resolved.parents:
+                        self.openapi_path = resolved
+                    else:
+                        logger.warning(
+                            f"[cross_lang] openapi_path {raw!r} resolves outside "
+                            f"project root; ignoring"
+                        )
+                except (OSError, RuntimeError) as e:
+                    logger.warning(f"Invalid [cross_lang] openapi_path: {e}")
+
         # [scip.rust]
         scip_rust = scip.get("rust", {})
         if "toolchain" in scip_rust:
@@ -752,9 +778,6 @@ class DescryService:
                     del self._dedup_cache[key]
             self._dedup_cache[content_hash] = (graph_mtime, node_id)
 
-    def _clear_dedup_cache(self):
-        self._dedup_cache = {}
-
     def reset_caches(self):
         """Reset all cached instances. Call after reindex."""
         self._graph_cache = {"mtime": 0, "nodes": 0, "edges": 0}
@@ -1712,7 +1735,13 @@ class DescryService:
         graph_path = (
             str(self.config.graph_path) if self.config.graph_path.exists() else None
         )
-        tracer = self._CrossLangTracer(str(openapi_path), graph_path)
+        tracer = self._CrossLangTracer(
+            str(openapi_path),
+            graph_path,
+            backend_handler_patterns=self.config.backend_handler_patterns or None,
+            frontend_api_patterns=self.config.frontend_api_patterns or None,
+            api_prefixes=self.config.api_prefixes or None,
+        )
 
         if mode == "stats":
             stats = tracer.get_stats()

{descry_codegraph-0.1.0 → descry_codegraph-0.1.1}/src/descry/mcp_server.py

@@ -94,8 +94,13 @@ _service: DescryService | None = None
 
 
 @asynccontextmanager
-async def server_lifespan(server: FastMCP):
-    """Pre-warm graph and embeddings on startup."""
+async def server_lifespan(_server: FastMCP):
+    """Pre-warm graph and embeddings on startup.
+
+    ``_server`` is the required lifespan-hook parameter injected by
+    FastMCP; the hook only mutates module-level state, so the arg is
+    intentionally unused.
+    """
     global _service
     config = DescryConfig.from_env()
     _service = DescryService(config)

{descry_codegraph-0.1.0 → descry_codegraph-0.1.1}/src/descry/query.py

@@ -19,7 +19,6 @@ MAX_CHILDREN_PER_LEVEL = 10  # Branching limit per level
 # Token budgets and thresholds
 DEFAULT_TOKEN_BUDGET = 2000  # Default token budget for expanded callees
 CALLEE_INLINE_THRESHOLD = 150  # Inline callees smaller than this (was 100)
-MAX_INLINE_THRESHOLD = 300  # Maximum allowed inline threshold
 MAX_CALLERS_SHOWN = 15  # Maximum callers to show in context
 
 # Timeout (milliseconds)

{descry_codegraph-0.1.0 → descry_codegraph-0.1.1}/src/descry/scip/parser.py

@@ -481,28 +481,6 @@ class ScipIndex:
 
         return names
 
-    def get_definition_location(self, symbol_id: str) -> Optional[Tuple[str, int]]:
-        """Get the definition location for a symbol.
-
-        Args:
-            symbol_id: SCIP symbol identifier
-
-        Returns:
-            Tuple of (file_path, line_number) or None if not found
-        """
-        return self.definitions.get(symbol_id)
-
-    def get_symbol_info(self, symbol_id: str) -> Optional[dict]:
-        """Get metadata for a symbol.
-
-        Args:
-            symbol_id: SCIP symbol identifier
-
-        Returns:
-            Dictionary with kind, display_name, documentation, or None
-        """
-        return self.symbols.get(symbol_id)
-
     def get_stats(self) -> dict:
         """Get statistics about the loaded index.
 

{descry_codegraph-0.1.0 → descry_codegraph-0.1.1}/src/descry/web/server.py

@@ -276,13 +276,28 @@ def _caller_to_dict(caller_id: str, q: GraphQuerier) -> dict:
     return result
 
 
-def _openapi_path_exists() -> bool:
-    """Check if an OpenAPI spec file exists in the project."""
+def _resolve_openapi_path() -> Path | None:
+    """Locate the project's OpenAPI spec, if any.
+
+    Order of precedence:
+    1. `[cross_lang] openapi_path` in .descry.toml (absolute or project-
+       relative; resolved by DescryConfig with a containment check).
+    2. `public/api/latest.json` under the project root.
+    3. `public/api/openapi.json` under the project root.
+    """
     cfg = _get_config()
+    if cfg.openapi_path and cfg.openapi_path.exists():
+        return cfg.openapi_path
     for name in ("latest.json", "openapi.json"):
-        if (cfg.project_root / "public" / "api" / name).exists():
-            return True
-    return False
+        candidate = cfg.project_root / "public" / "api" / name
+        if candidate.exists():
+            return candidate
+    return None
+
+
+def _openapi_path_exists() -> bool:
+    """Check if an OpenAPI spec file exists in the project."""
+    return _resolve_openapi_path() is not None
 
 
 # --- API Endpoint Handlers ---
@@ -857,19 +872,27 @@ async def api_cross_lang(request: Request) -> JSONResponse:
     tag = request.query_params.get("tag")
 
     cfg = _get_config()
-    openapi_path = cfg.project_root / "public" / "api" / "latest.json"
-    if not openapi_path.exists():
-        openapi_path = cfg.project_root / "public" / "api" / "openapi.json"
-    if not openapi_path.exists():
+    openapi_path = _resolve_openapi_path()
+    if openapi_path is None:
         return JSONResponse(
             {
                 "not_configured": True,
-                "message": "No OpenAPI spec found. Place your spec at public/api/openapi.json relative to the project root.",
+                "message": (
+                    "No OpenAPI spec found. Set [cross_lang] openapi_path in "
+                    ".descry.toml, or place a spec at public/api/openapi.json "
+                    "or public/api/latest.json relative to the project root."
+                ),
             }
         )
 
     graph_path = str(cfg.graph_path) if cfg.graph_path.exists() else None
-    tracer = CrossLangTracer(str(openapi_path), graph_path)
+    tracer = CrossLangTracer(
+        str(openapi_path),
+        graph_path,
+        backend_handler_patterns=cfg.backend_handler_patterns or None,
+        frontend_api_patterns=cfg.frontend_api_patterns or None,
+        api_prefixes=cfg.api_prefixes or None,
+    )
 
     if mode == "stats":
         return JSONResponse(tracer.get_stats())

{descry_codegraph-0.1.0 → descry_codegraph-0.1.1}/tests/test_config.py

@@ -268,6 +268,50 @@ extra_args = []
         assert config.syntax_lang_map[".rs"] == "rust"
         assert config.syntax_lang_map[".py"] == "python"
 
+    def test_cross_lang_section(self, tmp_path):
+        """[cross_lang] openapi_path + patterns reach DescryConfig."""
+        (tmp_path / "spec.json").write_text('{"openapi": "3.0.0"}')
+        (tmp_path / ".descry.toml").write_text(
+            'openapi_path = "spec.json"\n'
+            'backend_handler_patterns = ["handlers/"]\n'
+            'frontend_api_patterns = ["src/api/"]\n'
+            'api_prefixes = ["/api/v1", "/api/v2"]\n'.replace(
+                "openapi_path", "[cross_lang]\nopenapi_path"
+            )
+        )
+        config = DescryConfig(project_root=tmp_path)
+        config._apply_toml(DescryConfig._load_toml(tmp_path))
+
+        assert config.openapi_path == (tmp_path / "spec.json").resolve()
+        assert config.backend_handler_patterns == ["handlers/"]
+        assert config.frontend_api_patterns == ["src/api/"]
+        assert config.api_prefixes == ["/api/v1", "/api/v2"]
+
+    def test_cross_lang_openapi_path_outside_root_rejected(self, tmp_path, caplog):
+        """Paths resolving outside project_root are ignored with a warning."""
+        import logging
+
+        (tmp_path / ".descry.toml").write_text(
+            '[cross_lang]\nopenapi_path = "/etc/passwd"\n'
+        )
+        config = DescryConfig(project_root=tmp_path)
+        with caplog.at_level(logging.WARNING):
+            config._apply_toml(DescryConfig._load_toml(tmp_path))
+        assert config.openapi_path is None
+        assert any("outside project root" in r.message for r in caplog.records)
+
+    def test_cross_lang_openapi_path_absolute_inside_root(self, tmp_path):
+        """Absolute paths that resolve inside project_root are accepted."""
+        (tmp_path / "public").mkdir()
+        spec = tmp_path / "public" / "openapi.json"
+        spec.write_text('{"openapi":"3.0.0"}')
+        (tmp_path / ".descry.toml").write_text(
+            f'[cross_lang]\nopenapi_path = "{spec}"\n'
+        )
+        config = DescryConfig(project_root=tmp_path)
+        config._apply_toml(DescryConfig._load_toml(tmp_path))
+        assert config.openapi_path == spec.resolve()
+
 
 # --- Precedence ---
 

{descry_codegraph-0.1.0 → descry_codegraph-0.1.1}/tests/test_handlers.py

@@ -23,7 +23,6 @@ class TestDescryConfig:
         assert config.max_stale_hours == 24
         assert config.enable_scip is True
         assert config.enable_embeddings is True
-        assert ".git" in config.project_markers
 
     def test_from_env(self):
         config = DescryConfig.from_env()