codeboarding 0.9.6__tar.gz → 0.10.0__tar.gz

{codeboarding-0.9.6/codeboarding.egg-info → codeboarding-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeboarding
-Version: 0.9.6
+Version: 0.10.0
 Summary: Interactive Diagrams for Code
 Author: CodeBoarding Team
 License-Expression: MIT

{codeboarding-0.9.6 → codeboarding-0.10.0/codeboarding.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeboarding
-Version: 0.9.6
+Version: 0.10.0
 Summary: Interactive Diagrams for Code
 Author: CodeBoarding Team
 License-Expression: MIT

{codeboarding-0.9.6 → codeboarding-0.10.0}/codeboarding.egg-info/SOURCES.txt

@@ -122,12 +122,34 @@ static_analyzer/programming_language.py
 static_analyzer/reference_resolve_mixin.py
 static_analyzer/scanner.py
 static_analyzer/typescript_config_scanner.py
+static_analyzer/engine/__init__.py
+static_analyzer/engine/call_graph_builder.py
+static_analyzer/engine/edge_build_context.py
+static_analyzer/engine/edge_builder.py
+static_analyzer/engine/hierarchy_builder.py
+static_analyzer/engine/language_adapter.py
+static_analyzer/engine/lsp_client.py
+static_analyzer/engine/lsp_constants.py
+static_analyzer/engine/models.py
+static_analyzer/engine/progress.py
+static_analyzer/engine/protocols.py
+static_analyzer/engine/result_converter.py
+static_analyzer/engine/source_inspector.py
+static_analyzer/engine/symbol_table.py
+static_analyzer/engine/utils.py
+static_analyzer/engine/adapters/__init__.py
+static_analyzer/engine/adapters/go_adapter.py
+static_analyzer/engine/adapters/java_adapter.py
+static_analyzer/engine/adapters/php_adapter.py
+static_analyzer/engine/adapters/python_adapter.py
+static_analyzer/engine/adapters/typescript_adapter.py
 static_analyzer/lsp_client/__init__.py
 static_analyzer/lsp_client/diagnostics.py
 tests/test_github_action.py
 tests/test_install.py
 tests/test_logging_config.py
 tests/test_main.py
+tests/test_pyproject_packages.py
 tests/test_tool_registry.py
 tests/test_user_config.py
 tests/test_vscode_constants.py

{codeboarding-0.9.6 → codeboarding-0.10.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "codeboarding"
-version = "0.9.6"
+version = "0.10.0"
 description = "Interactive Diagrams for Code"
 readme = "PYPI.md"
 license = "MIT"
@@ -62,7 +62,7 @@ all = [
 ]
 
 [tool.setuptools]
-packages = ["agents", "agents.prompts", "agents.tools", "core", "diagram_analysis", "health", "health.checks", "monitoring", "output_generators", "repo_utils", "static_analyzer", "static_analyzer.lsp_client", "caching"]
+packages = ["agents", "agents.prompts", "agents.tools", "core", "diagram_analysis", "health", "health.checks", "monitoring", "output_generators", "repo_utils", "static_analyzer", "static_analyzer.engine", "static_analyzer.engine.adapters", "static_analyzer.lsp_client", "caching"]
 py-modules = ["constants", "utils", "vscode_constants", "logging_config", "duckdb_crud", "github_action", "tool_registry", "user_config", "main", "install"]
 include-package-data = true
 

codeboarding-0.10.0/static_analyzer/engine/__init__.py

@@ -0,0 +1,27 @@
+"""Engine package - LSP-based static analysis using global symbol-first approach."""
+
+from static_analyzer.engine.call_graph_builder import CallGraphBuilder
+from static_analyzer.engine.hierarchy_builder import HierarchyBuilder
+from static_analyzer.engine.language_adapter import LanguageAdapter
+from static_analyzer.engine.lsp_client import LSPClient
+from static_analyzer.engine.models import AnalysisResults, CallFlowGraph, Edge, LanguageAnalysisResult, SymbolInfo
+from static_analyzer.engine.result_converter import convert_to_codeboarding_format
+from static_analyzer.engine.source_inspector import SourceInspector
+from static_analyzer.engine.symbol_table import SymbolTable
+from static_analyzer.engine.utils import uri_to_path
+
+__all__ = [
+    "AnalysisResults",
+    "CallFlowGraph",
+    "CallGraphBuilder",
+    "Edge",
+    "HierarchyBuilder",
+    "LanguageAdapter",
+    "LanguageAnalysisResult",
+    "LSPClient",
+    "SourceInspector",
+    "SymbolInfo",
+    "SymbolTable",
+    "convert_to_codeboarding_format",
+    "uri_to_path",
+]

codeboarding-0.10.0/static_analyzer/engine/adapters/__init__.py

@@ -0,0 +1,32 @@
+"""Language adapter registry."""
+
+from __future__ import annotations
+
+from static_analyzer.engine.language_adapter import LanguageAdapter
+from static_analyzer.engine.adapters.go_adapter import GoAdapter
+from static_analyzer.engine.adapters.java_adapter import JavaAdapter
+from static_analyzer.engine.adapters.php_adapter import PHPAdapter
+from static_analyzer.engine.adapters.python_adapter import PythonAdapter
+from static_analyzer.engine.adapters.typescript_adapter import JavaScriptAdapter, TypeScriptAdapter
+
+ADAPTER_REGISTRY: dict[str, type[LanguageAdapter]] = {
+    "Python": PythonAdapter,
+    "JavaScript": JavaScriptAdapter,
+    "TypeScript": TypeScriptAdapter,
+    "Go": GoAdapter,
+    "Java": JavaAdapter,
+    "PHP": PHPAdapter,
+}
+
+
+def get_adapter(language: str) -> LanguageAdapter:
+    """Get an adapter instance for the given language."""
+    cls = ADAPTER_REGISTRY.get(language)
+    if cls is None:
+        raise ValueError(f"No adapter for language: {language}")
+    return cls()
+
+
+def get_all_adapters() -> dict[str, LanguageAdapter]:
+    """Get instances of all registered adapters."""
+    return {lang: cls() for lang, cls in ADAPTER_REGISTRY.items()}

codeboarding-0.10.0/static_analyzer/engine/adapters/go_adapter.py

@@ -0,0 +1,207 @@
+"""Go language adapter using gopls."""
+
+from __future__ import annotations
+
+import logging
+import re
+from pathlib import Path
+
+from repo_utils.ignore import RepoIgnoreManager, _ALWAYS_IGNORED_DIRS
+from static_analyzer.engine.language_adapter import LanguageAdapter
+
+logger = logging.getLogger(__name__)
+
+# Matches patterns like "**/dirname/**" or "**/dirname/"
+_RECURSIVE_DIR_RE = re.compile(r"^\*\*/([a-zA-Z0-9_\-]+)(?:/\*\*)?/?$")
+# Matches patterns like "dirname/" (bare directory)
+_BARE_DIR_RE = re.compile(r"^([a-zA-Z0-9_\-]+)/$")
+
+
+def _directory_filters_from_ignore_manager(ignore_manager: RepoIgnoreManager | None) -> list[str]:
+    """Convert .codeboardingignore directory patterns to gopls directoryFilters.
+
+    Extracts directory-level patterns from the ignore manager's codeboardingignore
+    spec and converts them to gopls format (``-**/dirname``). File-level patterns
+    (e.g. ``*.test.*``) are skipped — gopls only supports directory filtering.
+
+    Also includes the always-ignored directories (node_modules, build, etc.).
+    """
+    filters: list[str] = []
+    seen: set[str] = set()
+
+    # Always-ignored directories first
+    for dirname in sorted(_ALWAYS_IGNORED_DIRS):
+        key = dirname.lower()
+        if key not in seen:
+            seen.add(key)
+            filters.append(f"-**/{dirname}")
+
+    if ignore_manager is None:
+        return filters
+
+    # Parse the codeboardingignore patterns for directory entries
+    for line in ignore_manager._load_codeboardingignore_patterns():
+        pattern = line.strip()
+        if not pattern or pattern.startswith("#") or pattern.startswith("!"):
+            continue
+
+        # Match "**/dirname/**" or "**/dirname/"
+        m = _RECURSIVE_DIR_RE.match(pattern)
+        if m:
+            dirname = m.group(1)
+            key = dirname.lower()
+            if key not in seen:
+                seen.add(key)
+                filters.append(f"-**/{dirname}")
+            continue
+
+        # Match "dirname/"
+        m = _BARE_DIR_RE.match(pattern)
+        if m:
+            dirname = m.group(1)
+            key = dirname.lower()
+            if key not in seen:
+                seen.add(key)
+                filters.append(f"-**/{dirname}")
+            continue
+
+    return filters
+
+
+class GoAdapter(LanguageAdapter):
+
+    @property
+    def language(self) -> str:
+        return "Go"
+
+    @property
+    def file_extensions(self) -> tuple[str, ...]:
+        return (".go",)
+
+    @property
+    def lsp_command(self) -> list[str]:
+        return ["gopls", "serve"]
+
+    @property
+    def language_id(self) -> str:
+        return "go"
+
+    def build_qualified_name(
+        self,
+        file_path: Path,
+        symbol_name: str,
+        symbol_kind: int,
+        parent_chain: list[tuple[str, int]],
+        project_root: Path,
+        detail: str = "",
+    ) -> str:
+        rel = file_path.relative_to(project_root)
+        dir_parts = list(rel.parent.parts) if rel.parent != Path(".") else []
+        file_stem = rel.stem
+        module = ".".join(dir_parts + [file_stem]) if dir_parts else file_stem
+
+        if parent_chain:
+            receiver_name, receiver_kind = parent_chain[-1]
+            is_pointer = self._is_pointer_receiver(detail, receiver_name)
+            if is_pointer:
+                return f"{module}.(*{receiver_name}).{symbol_name}"
+            else:
+                return f"{module}.({receiver_name}).{symbol_name}"
+        return f"{module}.{symbol_name}"
+
+    @staticmethod
+    def _is_pointer_receiver(detail: str, receiver_name: str) -> bool:
+        if not detail:
+            return False
+        return f"*{receiver_name}" in detail or f"* {receiver_name}" in detail
+
+    def build_reference_key(self, qualified_name: str) -> str:
+        """Preserve original casing for Go qualified names."""
+        return qualified_name
+
+    def get_lsp_init_options(self, ignore_manager: RepoIgnoreManager | None = None) -> dict:
+        """Configure gopls for lower memory usage.
+
+        - ``directoryFilters``: derived from ``.codeboardingignore`` patterns
+          so user customizations automatically flow to gopls. Tells gopls to
+          skip directories entirely (never loaded into memory).
+        - ``analyses``: disables all optional static analyzers. We only need
+          documentSymbol and references for call-graph construction. Core
+          diagnostics (unused imports/variables) still work because they come
+          from the Go type-checker, not from analyzers.
+        """
+        directory_filters = _directory_filters_from_ignore_manager(ignore_manager)
+        # gopls expects flat settings (no "gopls" wrapper) in initializationOptions.
+        # The "gopls" nesting seen in editor configs is an editor convention.
+        return {
+            "directoryFilters": directory_filters,
+            "analyses": {
+                "all": False,
+                # Re-enable unused-code analyzers for dead-code detection.
+                # Both are off by default and must be explicitly enabled.
+                # unusedparams: flags unused function parameters.
+                # unusedfunc: flags unused unexported functions.
+                # unusedvariable is intentionally omitted — it only provides
+                # quick-fixes for existing compiler errors, not new diagnostics.
+                "unusedparams": True,
+                "unusedfunc": True,
+            },
+        }
+
+    def get_workspace_settings(self) -> dict | None:
+        # gopls requests settings via workspace/configuration with section "gopls".
+        # The response must be a flat settings object (no "gopls" wrapper).
+        return {
+            "analyses": {
+                "unusedparams": True,
+                "unusedfunc": True,
+            },
+            "ui.diagnostic.staticcheck": True,
+        }
+
+    def get_lsp_env(self) -> dict[str, str]:
+        """Tune Go GC for lower peak memory at the cost of more CPU.
+
+        ``GOGC=50`` makes the garbage collector run more frequently (default
+        is 100), roughly halving peak heap size for memory-intensive workloads
+        like gopls indexing large repositories.
+        Avoids OOM errors on large codebases, especially in constrained environments like CI.
+        """
+        return {"GOGC": "50"}
+
+    def discover_source_files(self, project_root: Path, ignore_manager: RepoIgnoreManager) -> list[Path]:
+        """Discover Go source files, filtering out build-tag-constrained files.
+
+        Files with ``//go:build`` or ``// +build`` directives containing
+        negations (``!``) are excluded because gopls cannot resolve package
+        metadata for them, which causes errors during cross-reference queries.
+        """
+        files = super().discover_source_files(project_root, ignore_manager)
+        filtered = [f for f in files if not self._has_excluding_build_tag(f)]
+        skipped = len(files) - len(filtered)
+        if skipped:
+            logger.info("Filtered %d Go files with excluding build tags", skipped)
+        return filtered
+
+    @staticmethod
+    def _has_excluding_build_tag(file_path: Path) -> bool:
+        """Check if a Go file has a build constraint with negation."""
+        try:
+            with open(file_path, "r", errors="replace") as f:
+                for line in f:
+                    stripped = line.strip()
+                    if not stripped or stripped.startswith("//"):
+                        if stripped.startswith("//go:build ") or stripped.startswith("// +build "):
+                            tag_expr = (
+                                stripped.split(" ", 2)[-1]
+                                if stripped.startswith("// +build")
+                                else stripped[len("//go:build ") :]
+                            )
+                            if "!" in tag_expr:
+                                return True
+                        continue
+                    # Stop at the first non-comment, non-blank line (typically "package ...")
+                    break
+        except OSError:
+            pass
+        return False

codeboarding-0.10.0/static_analyzer/engine/adapters/java_adapter.py

@@ -0,0 +1,295 @@
+"""Java language adapter using JDTLS."""
+
+from __future__ import annotations
+
+import logging
+import os
+import platform
+import tempfile
+from pathlib import Path
+
+from static_analyzer.engine.language_adapter import LanguageAdapter
+from static_analyzer.constants import NodeType
+from static_analyzer.engine.lsp_constants import (
+    CALLABLE_KINDS,
+    CLASS_LIKE_KINDS,
+    EdgeStrategy,
+)
+from static_analyzer.java_utils import create_jdtls_command, find_java_21_or_later
+from utils import get_config
+
+logger = logging.getLogger(__name__)
+
+
+class JavaAdapter(LanguageAdapter):
+
+    @property
+    def language(self) -> str:
+        return "Java"
+
+    @property
+    def file_extensions(self) -> tuple[str, ...]:
+        return (".java",)
+
+    @property
+    def lsp_command(self) -> list[str]:
+        return ["jdtls"]
+
+    @property
+    def language_id(self) -> str:
+        return "java"
+
+    def get_lsp_command(self, project_root: Path) -> list[str]:
+        """Build the full JDTLS launch command.
+
+        JDTLS cannot be started with a simple binary name — it requires a Java
+        executable, the Equinox launcher JAR, a config directory, and a unique
+        workspace data directory.  We resolve the jdtls_root from the tool
+        registry config and delegate to ``create_jdtls_command``.
+        """
+        jdtls_root = self._find_jdtls_root()
+        if jdtls_root is None:
+            raise RuntimeError(
+                "JDTLS installation not found. Run `python install.py` or " "set the jdtls_root in the tool config."
+            )
+
+        java_home = find_java_21_or_later()
+        if java_home is None:
+            raise RuntimeError("Java 21+ required to run JDTLS. Please install JDK 21 or later.")
+
+        workspace_dir = Path(tempfile.mkdtemp(prefix="jdtls-workspace-"))
+        heap_size = self._calculate_heap_size(project_root)
+        return create_jdtls_command(jdtls_root, workspace_dir, java_home, heap_size)
+
+    @staticmethod
+    def _find_jdtls_root() -> Path | None:
+        """Locate the JDTLS installation directory."""
+        # 1. Check tool registry config (set by install.py / resolve_config)
+        lsp_servers = get_config("lsp_servers")
+        java_entry = lsp_servers.get("java", {})
+        if root_str := java_entry.get("jdtls_root"):
+            root = Path(root_str)
+            if root.is_dir() and (root / "plugins").is_dir():
+                return root
+
+        # 2. Fallback to well-known locations (platform-specific)
+        well_known: list[Path] = [
+            Path.home() / ".jdtls",
+            Path.home() / ".codeboarding" / "servers" / "bin" / "jdtls",
+        ]
+        if platform.system() == "Windows":
+            local_app_data = os.environ.get("LOCALAPPDATA", "")
+            if local_app_data:
+                well_known.append(Path(local_app_data) / "jdtls")
+            program_files = os.environ.get("ProgramFiles", "C:\\Program Files")
+            well_known.append(Path(program_files) / "jdtls")
+        else:
+            well_known.append(Path("/opt/jdtls"))
+
+        for location in well_known:
+            if location.is_dir() and (location / "plugins").is_dir():
+                logger.info(f"Found JDTLS at {location}")
+                return location
+
+        return None
+
+    @staticmethod
+    def _calculate_heap_size(project_root: Path) -> str:
+        """Calculate appropriate JVM heap size based on file count and available system memory.
+
+        Caps the heap at ~50% of physical RAM to avoid starving the OS and other processes.
+        """
+        jvm_files = (
+            list(project_root.rglob("*.java")) + list(project_root.rglob("*.kt")) + list(project_root.rglob("*.groovy"))
+        )
+        file_count = len(jvm_files)
+        if file_count < 100:
+            desired_gb = 1
+        elif file_count < 500:
+            desired_gb = 2
+        elif file_count < 2000:
+            desired_gb = 4
+        elif file_count < 5000:
+            desired_gb = 6
+        else:
+            desired_gb = 8
+
+        # Cap at 50% of available physical memory
+        try:
+            total_ram_bytes = os.sysconf("SC_PAGE_SIZE") * os.sysconf("SC_PHYS_PAGES")
+            total_ram_gb = total_ram_bytes / (1024**3)
+            max_heap_gb = max(1, int(total_ram_gb * 0.5))
+            desired_gb = min(desired_gb, max_heap_gb)
+        except (ValueError, OSError):
+            pass  # os.sysconf not available (e.g. Windows) — use file-count estimate as-is
+
+        return f"{desired_gb}G"
+
+    def build_qualified_name(
+        self,
+        file_path: Path,
+        symbol_name: str,
+        symbol_kind: int,
+        parent_chain: list[tuple[str, int]],
+        project_root: Path,
+        detail: str = "",
+    ) -> str:
+        rel = file_path.relative_to(project_root)
+        module = ".".join(rel.with_suffix("").parts)
+        clean_name = self._clean_symbol_name(symbol_name)
+
+        if parent_chain:
+            # In Java, the filename IS the top-level class name (e.g., Dog.java -> module "...Dog").
+            # Skip the first parent if it matches the last module component to avoid
+            # doubled names like "core.Dog.Dog.speak()" -> "core.Dog.speak()".
+            module_last = module.rsplit(".", 1)[-1] if "." in module else module
+            effective_parents = list(parent_chain)
+            if effective_parents and self._clean_symbol_name(effective_parents[0][0]) == module_last:
+                effective_parents = effective_parents[1:]
+
+            if effective_parents:
+                clean_parents = ".".join(self._clean_symbol_name(name) for name, _ in effective_parents)
+                return f"{module}.{clean_parents}.{clean_name}"
+        return f"{module}.{clean_name}"
+
+    @staticmethod
+    def _clean_symbol_name(name: str) -> str:
+        """Clean a JDTLS symbol name by stripping generics from params."""
+        stripped = name.strip()
+        paren_idx = stripped.find("(")
+        if paren_idx == -1:
+            return stripped
+
+        depth = 0
+        close_idx = -1
+        for i in range(paren_idx, len(stripped)):
+            if stripped[i] == "(":
+                depth += 1
+            elif stripped[i] == ")":
+                depth -= 1
+                if depth == 0:
+                    close_idx = i
+                    break
+
+        if close_idx == -1:
+            return stripped
+
+        method_name = stripped[:paren_idx]
+        params_raw = stripped[paren_idx + 1 : close_idx]
+        suffix = stripped[close_idx + 1 :].strip()
+
+        if suffix.startswith("<"):
+            suffix = ""
+
+        params = []
+        for param in JavaAdapter._split_params(params_raw):
+            param = param.strip()
+            if not param:
+                continue
+            params.append(JavaAdapter._strip_generics(param))
+
+        result = f"{method_name}({', '.join(params)})"
+        if suffix:
+            result += " " + suffix
+        return result
+
+    @staticmethod
+    def _strip_generics(param: str) -> str:
+        """Strip generic type parameters: 'List<Animal>' -> 'List'."""
+        result = []
+        depth = 0
+        for ch in param:
+            if ch == "<":
+                depth += 1
+            elif ch == ">":
+                depth -= 1
+            elif depth == 0:
+                result.append(ch)
+        return "".join(result).strip()
+
+    @staticmethod
+    def _split_params(raw: str) -> list[str]:
+        """Split parameter list respecting angle brackets."""
+        params = []
+        depth = 0
+        current: list[str] = []
+        for ch in raw:
+            if ch == "<":
+                depth += 1
+                current.append(ch)
+            elif ch == ">":
+                depth -= 1
+                current.append(ch)
+            elif ch == "," and depth == 0:
+                params.append("".join(current))
+                current = []
+            else:
+                current.append(ch)
+        if current:
+            params.append("".join(current))
+        return params
+
+    def extract_package(self, qualified_name: str) -> str:
+        parts = qualified_name.split(".")
+
+        java_idx = None
+        for i, part in enumerate(parts):
+            if part == "java" and i >= 1 and parts[i - 1] == "main":
+                java_idx = i
+                break
+
+        if java_idx is None:
+            try:
+                java_idx = parts.index("java")
+            except ValueError:
+                return parts[0]
+
+        after_root = parts[java_idx + 1 :]
+        if not after_root:
+            return parts[0]
+
+        pkg_parts = []
+        for part in after_root:
+            clean = part.split("(")[0]
+            if clean in ("package-info", "module-info"):
+                break
+            if clean and clean[0].isupper():
+                break
+            pkg_parts.append(part)
+
+        if pkg_parts:
+            return ".".join(pkg_parts)
+        return after_root[0]
+
+    def get_workspace_settings(self) -> dict | None:
+        # JDTLS defaults these to "ignore"; raising to "warning" is required
+        # for unused-code diagnostics.
+        return {
+            "java": {
+                "settings": {
+                    "org.eclipse.jdt.core.compiler.problem.unusedImport": "warning",
+                    "org.eclipse.jdt.core.compiler.problem.unusedLocal": "warning",
+                    "org.eclipse.jdt.core.compiler.problem.unusedPrivateMember": "warning",
+                    "org.eclipse.jdt.core.compiler.problem.deadCode": "warning",
+                }
+            }
+        }
+
+    @property
+    def edge_strategy(self) -> EdgeStrategy:
+        """Use definition-based edges — JDTLS serializes references requests."""
+        return EdgeStrategy.DEFINITIONS
+
+    def should_track_for_edges(self, symbol_kind: int) -> bool:
+        return symbol_kind in (CALLABLE_KINDS | CLASS_LIKE_KINDS | {NodeType.VARIABLE, NodeType.CONSTANT})
+
+    def get_package_for_file(self, file_path: Path, project_root: Path) -> str:
+        """Get Java package from file path by stripping src/main/java/ prefix."""
+        qname = self.build_qualified_name(file_path, "", 0, [], project_root)
+        return self.extract_package(qname)
+
+    def get_all_packages(self, source_files: list[Path], project_root: Path) -> set[str]:
+        packages: set[str] = set()
+        for f in source_files:
+            packages.add(self.get_package_for_file(f, project_root))
+        return packages

codeboarding-0.10.0/static_analyzer/engine/adapters/php_adapter.py

@@ -0,0 +1,50 @@
+"""PHP language adapter using Intelephense."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from repo_utils.ignore import RepoIgnoreManager
+from static_analyzer.engine.language_adapter import LanguageAdapter
+from static_analyzer.constants import NodeType
+
+
+class PHPAdapter(LanguageAdapter):
+
+    @property
+    def language(self) -> str:
+        return "PHP"
+
+    @property
+    def file_extensions(self) -> tuple[str, ...]:
+        return (".php",)
+
+    @property
+    def lsp_command(self) -> list[str]:
+        return ["intelephense", "--stdio"]
+
+    @property
+    def language_id(self) -> str:
+        return "php"
+
+    def extract_package(self, qualified_name: str) -> str:
+        return self._extract_deep_package(qualified_name)
+
+    def get_lsp_init_options(self, ignore_manager: RepoIgnoreManager | None = None) -> dict:
+        return {"clearCache": False}
+
+    def get_workspace_settings(self) -> dict | None:
+        # unusedSymbols is already true by default but we set it defensively.
+        return {
+            "intelephense": {
+                "diagnostics": {
+                    "unusedSymbols": True,
+                }
+            }
+        }
+
+    def is_reference_worthy(self, symbol_kind: int) -> bool:
+        return super().is_reference_worthy(symbol_kind) or symbol_kind == NodeType.MODULE
+
+    def get_all_packages(self, source_files: list[Path], project_root: Path) -> set[str]:
+        return self._get_hierarchical_packages(source_files, project_root)