codecompass-mcp 2.3.0__tar.gz → 2.4.0__tar.gz

{codecompass_mcp-2.3.0 → codecompass_mcp-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecompass-mcp
-Version: 2.3.0
+Version: 2.4.0
 Summary: Structural code context for AI coding agents — a local code knowledge graph for blast radius, impact, deps, dead code, and flow tracing
 Author: CodeCompass contributors
 License: MIT

{codecompass_mcp-2.3.0 → codecompass_mcp-2.4.0}/codecompass_mcp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecompass-mcp
-Version: 2.3.0
+Version: 2.4.0
 Summary: Structural code context for AI coding agents — a local code knowledge graph for blast radius, impact, deps, dead code, and flow tracing
 Author: CodeCompass contributors
 License: MIT

{codecompass_mcp-2.3.0 → codecompass_mcp-2.4.0}/codecompass_mcp.egg-info/SOURCES.txt

@@ -32,5 +32,6 @@ tests/test_blast_radius.py
 tests/test_code_parser.py
 tests/test_ingestion.py
 tests/test_lit_css_parser.py
+tests/test_php_parser.py
 utils/__init__.py
 utils/formatting.py

{codecompass_mcp-2.3.0 → codecompass_mcp-2.4.0}/graph/code_graph_client.py

@@ -17,11 +17,13 @@ from models.code_types import CodeTriple, FileNode, FolderNode
 _EXT_TO_LANGUAGE = {
     ".py": "python",
     ".js": "javascript",
+    ".jsx": "javascript",
     ".ts": "typescript",
     ".tsx": "typescript",
     ".html": "html",
     ".css": "css",
     ".scss": "scss",
+    ".php": "php",
 }
 
 _ALLOWED_REL_TYPES = frozenset({

{codecompass_mcp-2.3.0 → codecompass_mcp-2.4.0}/graph/code_query_cli.py

@@ -667,6 +667,11 @@ _KIND_FILL = {
     "module": "#E8F5E9",
     "endpoint": "#FCE4EC",
     "variable": "#F3E5F5",
+    "interface": "#FFF8E1",
+    "trait": "#E0F7FA",
+    "enum": "#EDE7F6",
+    "property": "#FBE9E7",
+    "constant": "#F1F8E9",
 }
 
 

{codecompass_mcp-2.3.0 → codecompass_mcp-2.4.0}/ingestion/code_normalizer.py

@@ -44,7 +44,8 @@ Your job:
    POSTS_TO, INCLUDES, USED_BY, OVERRIDES, RAISES, RETURNS_TYPE.
 3. Correct entity types if obviously wrong.
    Allowed types: function, class, module, css_selector, html_element,
-   scss_mixin, scss_variable, endpoint, css_class, file.
+   scss_mixin, scss_variable, endpoint, css_class, file, interface, trait,
+   enum, property, constant.
 
 Return the same JSON array with corrections applied.
 Do NOT add, remove, or reorder triples.

{codecompass_mcp-2.3.0 → codecompass_mcp-2.4.0}/ingestion/code_parser.py

@@ -3,7 +3,7 @@
 Parses source files locally (no API calls) into typed CodeTriples.
 Uses direct AST node walking — compatible with any tree-sitter version.
 
-Supports: .py, .js, .ts, .tsx, .html, .css, .scss
+Supports: .py, .js, .jsx, .ts, .tsx, .html, .css, .scss, .php
 """
 
 from __future__ import annotations
@@ -21,7 +21,7 @@ from models.code_types import CodeTriple
 # Constants
 # ---------------------------------------------------------------------------
 
-SUPPORTED_EXTENSIONS = {".py", ".js", ".ts", ".tsx", ".html", ".css", ".scss", ".php"}
+SUPPORTED_EXTENSIONS = {".py", ".js", ".jsx", ".ts", ".tsx", ".html", ".css", ".scss", ".php"}
 
 # Relation types
 DEFINED_IN = "DEFINED_IN"
@@ -47,6 +47,23 @@ TYPE_SCSS_VARIABLE = "scss_variable"
 TYPE_ENDPOINT = "endpoint"
 TYPE_CSS_CLASS = "css_class"
 TYPE_FILE = "file"
+TYPE_INTERFACE = "interface"
+TYPE_TRAIT = "trait"
+TYPE_ENUM = "enum"
+TYPE_PROPERTY = "property"
+TYPE_CONSTANT = "constant"
+
+# PHP pseudo-class references that never resolve to a real, distinct entity.
+_PHP_SELF_REFERENTIAL = {"self", "static", "parent"}
+
+# Container node types that own PHP class-body members (properties, consts,
+# trait uses), mapped to the entity type of the container itself.
+_PHP_CONTAINER_TYPES = {
+    "class_declaration": TYPE_CLASS,
+    "trait_declaration": TYPE_TRAIT,
+    "interface_declaration": TYPE_INTERFACE,
+    "enum_declaration": TYPE_ENUM,
+}
 
 # Regex patterns for CSS/SCSS source scanning
 _CSS_VAR_RE = re.compile(r'var\(\s*(--[\w-]+)')
@@ -103,7 +120,7 @@ def _load_html_parser() -> tuple[Parser, Language]:
 
 def _load_php_parser() -> tuple[Parser, Language]:
     import tree_sitter_php as tsphp
-    return _make_parser(tsphp.language)
+    return _make_parser(tsphp.language_php)
 
 
 def _load_css_parser() -> tuple[Parser, Language]:
@@ -114,6 +131,7 @@ def _load_css_parser() -> tuple[Parser, Language]:
 _PARSER_LOADERS: dict[str, Callable[[], tuple[Parser, Language]]] = {
     ".py":   _load_python_parser,
     ".js":   _load_javascript_parser,
+    ".jsx":  _load_javascript_parser,
     ".ts":   _load_typescript_parser,
     ".tsx":  _load_tsx_parser,
     ".html": _load_html_parser,
@@ -218,7 +236,7 @@ def _extract_python(root: Node, source: bytes, file_path: str) -> list[CodeTripl
                             to_entity=_text(base),
                             to_type=TYPE_CLASS,
                             source_file=file_path,
-                            line_number=_line(name_node),
+                            line_number=_line(base),
                         ))
 
             case "import_statement":
@@ -299,68 +317,366 @@ def _extract_python_callee(call_node: Node) -> str | None:
 # ---------------------------------------------------------------------------
 # PHP extraction
 # ---------------------------------------------------------------------------
+#
+# Node-type names below were verified against tree_sitter_php 0.24.1 by
+# parsing representative snippets and inspecting the resulting AST directly
+# (the grammar ships no node-types.json in the pip package). Names differ
+# substantially from other PHP tree-sitter grammar versions found online —
+# e.g. classes are `class_declaration` (not `class_definition`), function
+# calls are `function_call_expression` (not `function_call`), and name
+# fields are typed `name` (not `identifier`).
+
+def _php_name(node: Node) -> str | None:
+    """Direct `name` child — used for the declared name of most PHP nodes."""
+    found = _child_of_type(node, "name")
+    return _text(found) if found else None
+
+
+def _php_basename(node: Node) -> str:
+    """Strip a namespace prefix: `App\\Models\\Foo` -> `Foo`. Also handles a
+    bare `name` node (no backslash) and a leading-backslash FQN (`\\Foo`)."""
+    return _text(node).rsplit("\\", 1)[-1]
+
+
+def _php_dotted(node: Node) -> str:
+    """Namespace-qualified name -> dotted form, matching the module-name
+    convention used elsewhere (`App\\Models\\Foo` -> `App.Models.Foo`)."""
+    return _text(node).lstrip("\\").replace("\\", ".")
+
+
+def _php_var_name(node: Node) -> str:
+    """`variable_name` node text (`$name`) -> bare name (`name`)."""
+    return _text(node).lstrip("$")
+
+
+def _php_extends_targets(clause: Node) -> list[Node]:
+    """`name`/`qualified_name` children of a base_clause or interface clause.
+
+    Handles both single-target class `extends` and multi-target interface
+    `extends`/`implements` (comma-separated siblings, not a nested list).
+    """
+    return [c for c in clause.children if c.type in ("name", "qualified_name")]
+
+
+def _enclosing_php_container(node: Node) -> tuple[str, str] | None:
+    """Walk up to the nearest enclosing class/trait/interface/enum.
+
+    Used to attach properties, constants, and trait-uses to their owner.
+    """
+    current = node.parent
+    while current:
+        entity_type = _PHP_CONTAINER_TYPES.get(current.type)
+        if entity_type:
+            name = _php_name(current)
+            if name:
+                return name, entity_type
+        current = current.parent
+    return None
+
+
+def _enclosing_php_scope(node: Node) -> tuple[str, str] | None:
+    """Walk up from node to find the nearest enclosing function/method/closure.
+
+    Closures (anonymous_function, arrow_function) only count as a scope if
+    assigned to a variable (`$fn = function() {...}`), whose name is then
+    used as the caller entity; unnamed inline closures are transparent and
+    resolution continues further up the tree.
+    """
+    current = node.parent
+    while current:
+        if current.type in ("function_definition", "method_declaration"):
+            name = _php_name(current)
+            if name:
+                return name, TYPE_FUNCTION
+        elif current.type in ("anonymous_function", "arrow_function"):
+            parent = current.parent
+            if parent and parent.type == "assignment_expression" and parent.children:
+                lhs = parent.children[0]
+                if lhs.type == "variable_name":
+                    return _php_var_name(lhs), TYPE_FUNCTION
+        current = current.parent
+    return None
+
+
+def _extract_php_namespace_use(node: Node) -> list[tuple[str, Node]]:
+    """Resolve every imported target of a `use ...;` statement to a dotted
+    name plus the node to attribute the line number to.
+
+    Handles plain (`use App\\Foo;`), aliased (`use App\\Foo as F;`), grouped
+    (`use App\\{Bar, Baz as Z};`), and `use function`/`use const` forms.
+    """
+    results: list[tuple[str, Node]] = []
+    group = _child_of_type(node, "namespace_use_group")
+    if group is not None:
+        prefix_node = _child_of_type(node, "namespace_name")
+        prefix = _text(prefix_node) if prefix_node else ""
+        for clause in _children_of_type(group, "namespace_use_clause"):
+            target = _child_of_type(clause, "qualified_name") or _child_of_type(clause, "name")
+            if target:
+                full = f"{prefix}\\{_text(target)}" if prefix else _text(target)
+                results.append((full.lstrip("\\").replace("\\", "."), target))
+    else:
+        for clause in _children_of_type(node, "namespace_use_clause"):
+            target = _child_of_type(clause, "qualified_name") or _child_of_type(clause, "name")
+            if target:
+                results.append((_php_dotted(target), target))
+    return results
+
+
+def _php_include_target(node: Node) -> Node | None:
+    """The literal string argument of a require/include expression, if any.
+
+    Dynamic paths (`require __DIR__ . '/x.php';`) have no plain `string`
+    child and are skipped — no static target to record.
+    """
+    return _child_of_type(node, "string")
+
+
+def _php_string_text(string_node: Node) -> str:
+    frag = _child_of_type(string_node, "string_content")
+    return _text(frag) if frag else _text(string_node).strip("'\"")
+
 
 def _extract_php(root: Node, source: bytes, file_path: str) -> list[CodeTriple]:
     module_name = _module_name_from_path(file_path)
     triples: list[CodeTriple] = []
 
+    def defined_in(name: str, entity_type: str, line: int) -> None:
+        triples.append(CodeTriple(
+            from_entity=name,
+            from_type=entity_type,
+            relation_type=DEFINED_IN,
+            to_entity=module_name,
+            to_type=TYPE_MODULE,
+            source_file=file_path,
+            line_number=line,
+        ))
+
+    def inherits(from_name: str, from_type: str, to_node: Node, to_type: str) -> None:
+        basename = _php_basename(to_node)
+        if basename and basename.lower() not in _PHP_SELF_REFERENTIAL:
+            triples.append(CodeTriple(
+                from_entity=from_name,
+                from_type=from_type,
+                relation_type=INHERITS,
+                to_entity=basename,
+                to_type=to_type,
+                source_file=file_path,
+                line_number=_line(to_node),
+            ))
+
+    def calls(callee: str, callee_type: str, line: int, scope_node: Node) -> None:
+        if not callee or not _is_meaningful_callee(callee):
+            return
+        scope = _enclosing_php_scope(scope_node)
+        caller, caller_type = scope if scope else (module_name, TYPE_MODULE)
+        triples.append(CodeTriple(
+            from_entity=caller,
+            from_type=caller_type,
+            relation_type=CALLS,
+            to_entity=callee,
+            to_type=callee_type,
+            source_file=file_path,
+            line_number=line,
+        ))
+
     for node in _walk(root):
         match node.type:
+            # -- Functions -----------------------------------------------
             case "function_definition":
-                name = _get_node_name(node, ["function_name", "identifier"])
+                name = _php_name(node)
+                if name:
+                    defined_in(name, TYPE_FUNCTION, _line(node))
+
+            case "method_declaration":
+                name = _php_name(node)
                 if name:
+                    defined_in(name, TYPE_FUNCTION, _line(node))
+
+            case "anonymous_function" | "arrow_function":
+                parent = node.parent
+                if parent and parent.type == "assignment_expression" and parent.children:
+                    lhs = parent.children[0]
+                    if lhs.type == "variable_name":
+                        defined_in(_php_var_name(lhs), TYPE_FUNCTION, _line(node))
+
+            # -- Classes / interfaces / traits / enums --------------------
+            case "class_declaration":
+                name = _php_name(node)
+                if not name:
+                    continue
+                defined_in(name, TYPE_CLASS, _line(node))
+                base_clause = _child_of_type(node, "base_clause")
+                if base_clause:
+                    for target in _php_extends_targets(base_clause):
+                        inherits(name, TYPE_CLASS, target, TYPE_CLASS)
+                iface_clause = _child_of_type(node, "class_interface_clause")
+                if iface_clause:
+                    for target in _php_extends_targets(iface_clause):
+                        inherits(name, TYPE_CLASS, target, TYPE_INTERFACE)
+
+            case "interface_declaration":
+                name = _php_name(node)
+                if not name:
+                    continue
+                defined_in(name, TYPE_INTERFACE, _line(node))
+                base_clause = _child_of_type(node, "base_clause")
+                if base_clause:
+                    for target in _php_extends_targets(base_clause):
+                        inherits(name, TYPE_INTERFACE, target, TYPE_INTERFACE)
+
+            case "trait_declaration":
+                name = _php_name(node)
+                if name:
+                    defined_in(name, TYPE_TRAIT, _line(node))
+
+            case "enum_declaration":
+                name = _php_name(node)
+                if not name:
+                    continue
+                defined_in(name, TYPE_ENUM, _line(node))
+                iface_clause = _child_of_type(node, "class_interface_clause")
+                if iface_clause:
+                    for target in _php_extends_targets(iface_clause):
+                        inherits(name, TYPE_ENUM, target, TYPE_INTERFACE)
+
+            case "enum_case":
+                container = _enclosing_php_container(node)
+                name = _php_name(node)
+                if name and container:
+                    container_name, container_type = container
                     triples.append(CodeTriple(
                         from_entity=name,
-                        from_type=TYPE_FUNCTION,
+                        from_type=TYPE_CONSTANT,
                         relation_type=DEFINED_IN,
-                        to_entity=module_name,
-                        to_type=TYPE_MODULE,
+                        to_entity=container_name,
+                        to_type=container_type,
                         source_file=file_path,
                         line_number=_line(node),
                     ))
 
-            case "class_definition":
-                name = _get_node_name(node, ["class_name", "identifier"])
-                if not name:
-                    continue
-                class_name = name
-
-                # Extract base classes (extends)
-                extends_node = _child_of_type(node, "extends_clause")
-                if extends_node:
-                    base_node = _child_of_type(extends_node, "type_name") or _child_of_type(extends_node, "identifier")
-                    if base_node:
+            # -- Trait usage inside a class/trait body --------------------
+            case "use_declaration":
+                container = _enclosing_php_container(node)
+                if container:
+                    container_name, container_type = container
+                    for target in _children_of_type(node, "name"):
                         triples.append(CodeTriple(
-                            from_entity=class_name,
-                            from_type=TYPE_CLASS,
+                            from_entity=container_name,
+                            from_type=container_type,
                             relation_type=INHERITS,
-                            to_entity=_text(base_node),
-                            to_type=TYPE_CLASS,
+                            to_entity=_text(target),
+                            to_type=TYPE_TRAIT,
                             source_file=file_path,
-                            line_number=_line(base_node),
+                            line_number=_line(target),
                         ))
 
-            case "function_call":
-                callee = _extract_php_callee(node)
-                if callee and _is_meaningful_callee(callee):
-                    scope = _enclosing_scope(node) # Reuse python-style scope walker for now
-                    caller = scope or module_name
-                    caller_type = TYPE_FUNCTION if scope else TYPE_MODULE
+            # -- Namespace imports -----------------------------------------
+            case "namespace_use_declaration":
+                for dotted, target_node in _extract_php_namespace_use(node):
                     triples.append(CodeTriple(
-                        from_entity=caller,
-                        from_type=caller_type,
-                        relation_type=CALLS,
-                        to_entity=callee,
-                        to_type=TYPE_FUNCTION,
+                        from_entity=module_name,
+                        from_type=TYPE_MODULE,
+                        relation_type=IMPORTS,
+                        to_entity=dotted,
+                        to_type=TYPE_MODULE,
                         source_file=file_path,
-                        line_number=_line(node),
+                        line_number=_line(target_node),
                     ))
 
-    return triples
+            # -- require/include -------------------------------------------
+            case "require_once_expression" | "require_expression" | "include_expression" | "include_once_expression":
+                str_node = _php_include_target(node)
+                if str_node:
+                    triples.append(CodeTriple(
+                        from_entity=module_name,
+                        from_type=TYPE_MODULE,
+                        relation_type=INCLUDES,
+                        to_entity=_php_string_text(str_node),
+                        to_type=TYPE_MODULE,
+                        source_file=file_path,
+                        line_number=_line(str_node),
+                    ))
+
+            # -- Properties / constructor-promoted properties ---------------
+            case "property_declaration":
+                container = _enclosing_php_container(node)
+                if container:
+                    container_name, container_type = container
+                    for element in _children_of_type(node, "property_element"):
+                        var_node = _child_of_type(element, "variable_name")
+                        if var_node:
+                            triples.append(CodeTriple(
+                                from_entity=_php_var_name(var_node),
+                                from_type=TYPE_PROPERTY,
+                                relation_type=DEFINED_IN,
+                                to_entity=container_name,
+                                to_type=container_type,
+                                source_file=file_path,
+                                line_number=_line(var_node),
+                            ))
+
+            case "property_promotion_parameter":
+                container = _enclosing_php_container(node)
+                var_node = _child_of_type(node, "variable_name")
+                if container and var_node:
+                    container_name, container_type = container
+                    triples.append(CodeTriple(
+                        from_entity=_php_var_name(var_node),
+                        from_type=TYPE_PROPERTY,
+                        relation_type=DEFINED_IN,
+                        to_entity=container_name,
+                        to_type=container_type,
+                        source_file=file_path,
+                        line_number=_line(var_node),
+                    ))
+
+            # -- Constants (class/interface/trait/enum or top-level) -------
+            case "const_declaration":
+                container = _enclosing_php_container(node)
+                for element in _children_of_type(node, "const_element"):
+                    name_node = _child_of_type(element, "name")
+                    if not name_node:
+                        continue
+                    to_entity, to_type = container if container else (module_name, TYPE_MODULE)
+                    triples.append(CodeTriple(
+                        from_entity=_text(name_node),
+                        from_type=TYPE_CONSTANT,
+                        relation_type=DEFINED_IN,
+                        to_entity=to_entity,
+                        to_type=to_type,
+                        source_file=file_path,
+                        line_number=_line(name_node),
+                    ))
+
+            # -- Calls -------------------------------------------------------
+            case "function_call_expression":
+                callee_node = _child_of_type(node, "name") or _child_of_type(node, "qualified_name")
+                if callee_node:
+                    calls(_php_basename(callee_node), TYPE_FUNCTION, _line(node), node)
 
+            case "member_call_expression" | "nullsafe_member_call_expression":
+                callee_node = _child_of_type(node, "name")
+                if callee_node:
+                    calls(_text(callee_node), TYPE_FUNCTION, _line(node), node)
 
-def _extract_php_callee(call_node: Node) -> str | None:
-    return _get_node_name(call_node, ["function_name", "identifier"])
+            case "scoped_call_expression":
+                names = _children_of_type(node, "name")
+                if names:
+                    calls(_text(names[-1]), TYPE_FUNCTION, _line(node), node)
+
+            case "object_creation_expression":
+                class_node = None
+                for child in node.children:
+                    if child.type in ("name", "qualified_name"):
+                        class_node = child
+                        break
+                if class_node:
+                    basename = _php_basename(class_node)
+                    if basename.lower() not in _PHP_SELF_REFERENTIAL:
+                        calls(basename, TYPE_CLASS, _line(node), node)
+
+    return triples
 
 # ---------------------------------------------------------------------------
 # JavaScript / TypeScript extraction
@@ -723,6 +1039,7 @@ def _extract_lit_css_tokens(source_text: str, file_path: str) -> list[CodeTriple
 _EXTRACTORS: dict[str, Callable] = {
     ".py":   _extract_python,
     ".js":   _extract_javascript,
+    ".jsx":  _extract_javascript,
     ".ts":   _extract_javascript,
     ".tsx":  _extract_javascript,
     ".html": _extract_html,

{codecompass_mcp-2.3.0 → codecompass_mcp-2.4.0}/models/code_types.py

@@ -8,7 +8,8 @@ class CodeTriple:
     """A single typed relationship extracted from source code."""
 
     from_entity: str
-    from_type: str   # function | class | module | css_selector | html_element | scss_mixin | scss_variable
+    from_type: str   # function | class | module | css_selector | html_element | scss_mixin | scss_variable |
+                      # interface | trait | enum | property | constant
     relation_type: str  # CALLS | IMPORTS | INHERITS | DEFINED_IN | STYLES | HAS_CLASS | POSTS_TO | INCLUDES | USED_BY
     to_entity: str
     to_type: str

{codecompass_mcp-2.3.0 → codecompass_mcp-2.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codecompass-mcp"
-version = "2.3.0"
+version = "2.4.0"
 description = "Structural code context for AI coding agents — a local code knowledge graph for blast radius, impact, deps, dead code, and flow tracing"
 readme = "README.md"
 license = {text = "MIT"}

codecompass_mcp-2.4.0/tests/test_php_parser.py

@@ -0,0 +1,217 @@
+"""Tests for PHP ingestion entity coverage."""
+from __future__ import annotations
+
+import os
+import sys
+import tempfile
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
+
+from ingestion.code_parser import parse_file
+
+
+def _parse(content: str) -> list:
+    with tempfile.NamedTemporaryFile(suffix=".php", mode="w", delete=False) as f:
+        f.write(content)
+        path = f.name
+    try:
+        return parse_file(path, os.path.dirname(path))
+    finally:
+        os.unlink(path)
+
+
+def _rels(triples, relation_type=None, from_type=None, to_type=None):
+    out = triples
+    if relation_type is not None:
+        out = [t for t in out if t.relation_type == relation_type]
+    if from_type is not None:
+        out = [t for t in out if t.from_type == from_type]
+    if to_type is not None:
+        out = [t for t in out if t.to_type == to_type]
+    return out
+
+
+# ---------------------------------------------------------------------------
+# The parser must actually run — regression guard for the broken loader
+# (tsphp.language vs tsphp.language_php) that silently no-op'd every .php file.
+# ---------------------------------------------------------------------------
+
+def test_php_file_parses_without_error():
+    triples = _parse("<?php\nfunction foo() { return 1; }\n")
+    assert triples, "PHP parsing should produce triples, not silently fail"
+
+
+# ---------------------------------------------------------------------------
+# Functions, classes, inheritance
+# ---------------------------------------------------------------------------
+
+def test_top_level_function_indexed():
+    triples = _parse("<?php\nfunction topLevel($x) { return $x; }\n")
+    defs = _rels(triples, relation_type="DEFINED_IN", from_type="function")
+    assert any(t.from_entity == "topLevel" for t in defs)
+
+
+def test_class_extends_indexed():
+    triples = _parse("<?php\nclass Foo extends Bar {}\n")
+    inh = _rels(triples, relation_type="INHERITS", to_type="class")
+    assert any(t.from_entity == "Foo" and t.to_entity == "Bar" for t in inh)
+
+
+def test_class_implements_indexed():
+    triples = _parse("<?php\nclass Foo implements A, B {}\n")
+    inh = _rels(triples, relation_type="INHERITS", to_type="interface")
+    targets = {t.to_entity for t in inh}
+    assert {"A", "B"} <= targets
+
+
+# ---------------------------------------------------------------------------
+# Methods, properties, constructor promotion, constants
+# ---------------------------------------------------------------------------
+
+def test_class_method_indexed():
+    src = "<?php\nclass Foo {\n    public function bar() { return 1; }\n}\n"
+    triples = _parse(src)
+    defs = _rels(triples, relation_type="DEFINED_IN", from_type="function")
+    assert any(t.from_entity == "bar" for t in defs)
+
+
+def test_property_declaration_indexed():
+    src = "<?php\nclass Foo {\n    protected static ?string $name = \"x\";\n}\n"
+    triples = _parse(src)
+    props = _rels(triples, relation_type="DEFINED_IN", from_type="property")
+    assert any(t.from_entity == "name" and t.to_entity == "Foo" for t in props)
+
+
+def test_constructor_promoted_property_indexed():
+    src = "<?php\nclass Foo {\n    public function __construct(private readonly int $id) {}\n}\n"
+    triples = _parse(src)
+    props = _rels(triples, relation_type="DEFINED_IN", from_type="property")
+    assert any(t.from_entity == "id" and t.to_entity == "Foo" for t in props)
+
+
+def test_class_constant_indexed():
+    src = "<?php\nclass Foo {\n    public const MAX = 10;\n}\n"
+    triples = _parse(src)
+    consts = _rels(triples, relation_type="DEFINED_IN", from_type="constant")
+    assert any(t.from_entity == "MAX" and t.to_entity == "Foo" for t in consts)
+
+
+def test_top_level_constant_indexed():
+    triples = _parse("<?php\nconst MAX = 10;\n")
+    consts = _rels(triples, relation_type="DEFINED_IN", from_type="constant")
+    assert any(t.from_entity == "MAX" and t.to_type == "module" for t in consts)
+
+
+# ---------------------------------------------------------------------------
+# Interfaces, traits, enums
+# ---------------------------------------------------------------------------
+
+def test_interface_declaration_indexed():
+    triples = _parse("<?php\ninterface Payable {\n    public function pay(): void;\n}\n")
+    defs = _rels(triples, relation_type="DEFINED_IN", from_type="interface")
+    assert any(t.from_entity == "Payable" for t in defs)
+
+
+def test_interface_extends_multiple_indexed():
+    triples = _parse("<?php\ninterface Multi extends X, Y {}\n")
+    inh = _rels(triples, relation_type="INHERITS", from_type="interface", to_type="interface")
+    targets = {t.to_entity for t in inh}
+    assert {"X", "Y"} <= targets
+
+
+def test_trait_declaration_and_use_indexed():
+    src = "<?php\ntrait Loggable {\n    public function log() {}\n}\nclass Foo {\n    use Loggable;\n}\n"
+    triples = _parse(src)
+    trait_defs = _rels(triples, relation_type="DEFINED_IN", from_type="trait")
+    assert any(t.from_entity == "Loggable" for t in trait_defs)
+    uses = _rels(triples, relation_type="INHERITS", to_type="trait")
+    assert any(t.from_entity == "Foo" and t.to_entity == "Loggable" for t in uses)
+
+
+def test_enum_and_case_indexed():
+    src = "<?php\nenum Status: string {\n    case Active = 'active';\n}\n"
+    triples = _parse(src)
+    enum_defs = _rels(triples, relation_type="DEFINED_IN", from_type="enum")
+    assert any(t.from_entity == "Status" for t in enum_defs)
+    cases = _rels(triples, relation_type="DEFINED_IN", from_type="constant", to_type="enum")
+    assert any(t.from_entity == "Active" and t.to_entity == "Status" for t in cases)
+
+
+# ---------------------------------------------------------------------------
+# Namespaces / imports / includes
+# ---------------------------------------------------------------------------
+
+def test_namespace_use_indexed():
+    triples = _parse("<?php\nuse App\\Contracts\\Payable;\n")
+    imports = _rels(triples, relation_type="IMPORTS")
+    assert any(t.to_entity == "App.Contracts.Payable" for t in imports)
+
+
+def test_namespace_use_group_indexed():
+    triples = _parse("<?php\nuse App\\{Bar, Baz};\n")
+    imports = _rels(triples, relation_type="IMPORTS")
+    targets = {t.to_entity for t in imports}
+    assert {"App.Bar", "App.Baz"} <= targets
+
+
+def test_require_once_indexed():
+    triples = _parse("<?php\nrequire_once 'bootstrap.php';\n")
+    includes = _rels(triples, relation_type="INCLUDES")
+    assert any(t.to_entity == "bootstrap.php" for t in includes)
+
+
+# ---------------------------------------------------------------------------
+# Calls: plain, method, static, new, closures
+# ---------------------------------------------------------------------------
+
+def test_plain_function_call_indexed():
+    triples = _parse("<?php\nfunction outer() { inner(); }\nfunction inner() {}\n")
+    calls = _rels(triples, relation_type="CALLS")
+    assert any(t.from_entity == "outer" and t.to_entity == "inner" for t in calls)
+
+
+def test_method_call_indexed():
+    src = "<?php\nfunction run() {\n    $obj = new Foo();\n    $obj->save();\n}\n"
+    triples = _parse(src)
+    calls = _rels(triples, relation_type="CALLS")
+    assert any(t.to_entity == "save" and t.to_type == "function" for t in calls)
+    assert any(t.to_entity == "Foo" and t.to_type == "class" for t in calls)
+
+
+def test_static_call_indexed():
+    src = "<?php\nfunction run() {\n    BaseModel::make();\n}\n"
+    triples = _parse(src)
+    calls = _rels(triples, relation_type="CALLS")
+    assert any(t.to_entity == "make" for t in calls)
+
+
+def test_self_new_not_recorded_as_class_entity():
+    src = "<?php\nclass Foo {\n    public static function make() {\n        return new static();\n    }\n}\n"
+    triples = _parse(src)
+    calls = _rels(triples, relation_type="CALLS", to_type="class")
+    assert not any(t.to_entity.lower() in ("self", "static", "parent") for t in calls)
+
+
+def test_closure_assigned_to_variable_indexed():
+    src = "<?php\nfunction run() {\n    $fn = function($x) { return $x; };\n}\n"
+    triples = _parse(src)
+    defs = _rels(triples, relation_type="DEFINED_IN", from_type="function")
+    assert any(t.from_entity == "fn" for t in defs)
+
+
+def test_arrow_function_assigned_to_variable_indexed():
+    src = "<?php\nfunction run() {\n    $arrow = fn($x) => $x + 1;\n}\n"
+    triples = _parse(src)
+    defs = _rels(triples, relation_type="DEFINED_IN", from_type="function")
+    assert any(t.from_entity == "arrow" for t in defs)
+
+
+# ---------------------------------------------------------------------------
+# No regression on other extractors
+# ---------------------------------------------------------------------------
+
+def test_php_does_not_emit_html_relations():
+    triples = _parse("<?php\nclass Foo {}\n")
+    rel_types = {t.relation_type for t in triples}
+    assert "HAS_CLASS" not in rel_types
+    assert "STYLES" not in rel_types