codecompass-mcp 2.8.0__tar.gz → 3.0.0__tar.gz

{codecompass_mcp-2.8.0 → codecompass_mcp-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecompass-mcp
-Version: 2.8.0
+Version: 3.0.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.8.0 → codecompass_mcp-3.0.0}/codecompass_mcp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecompass-mcp
-Version: 2.8.0
+Version: 3.0.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.8.0 → codecompass_mcp-3.0.0}/graph/code_graph_client.py

@@ -37,12 +37,15 @@ def _now() -> str:
     return datetime.now(timezone.utc).isoformat()
 
 
-def _entity_id(project: str, name: str, file: str | None) -> str:
-    """Node id for an entity — file-qualified so same-named entities in different
-    files stay distinct. Case is preserved so `Session` (class) and `session`
-    (function) don't collide. External/module targets with no file are name-only."""
+def _entity_id(project: str, name: str, file: str | None, owner: str | None = None) -> str:
+    """Node id for an entity — file- and class-qualified so same-named entities
+    stay distinct across files AND across classes in the same file. Case is
+    preserved so `Session` (class) and `session` (function) don't collide.
+    External/module targets with no file are name-only.
+    """
     if file:
-        return f"{project}:{file}:{name}"
+        local = f"{owner}.{name}" if owner else name
+        return f"{project}:{file}:{local}"
     return f"{project}:{name}"
 
 
@@ -225,6 +228,8 @@ class LocalGraphClient:
         # later non-exported definition clear a flag an earlier one set.
         if getattr(triple, "is_exported", False):
             self.graph.nodes[from_id]["is_exported"] = True
+        if getattr(triple, "owner_class", None):
+            self.graph.nodes[from_id]["owner"] = triple.owner_class
 
         # Upsert to entity — only set language/kind/description if not already known
         self.graph.add_node(to_id)
@@ -260,13 +265,18 @@ class LocalGraphClient:
         name = triple.to_entity
         if triple.relation_type == "DEFINED_IN":
             return f"{project}:{name}"  # module container — name-only
-        cands = defs_by_name.get(name)
+        cands = defs_by_name.get(name)  # list of (node_id, file, owner)
         if cands:
             rt = getattr(triple, "call_receiver_type", None)
             if rt:
+                # strongest: a definition owned by exactly the receiver's class
+                for nid, f, owner in cands:
+                    if owner == rt:
+                        return nid
+                # next: any definition in the receiver class's file
                 cf = class_file.get(rt)
                 if cf:
-                    for nid, f in cands:
+                    for nid, f, owner in cands:
                         if f == cf:
                             return nid
             if len(cands) == 1:
@@ -281,19 +291,21 @@ class LocalGraphClient:
         project: str
     ) -> int:
         # Pass 1: index every definition so calls can resolve to a specific one.
-        defs_by_name: dict[str, list] = {}
+        defs_by_name: dict[str, list] = {}   # name -> [(node_id, file, owner)]
         class_file: dict[str, str] = {}
         for t in triples:
             if t.relation_type == "DEFINED_IN":
-                nid = _entity_id(project, t.from_entity, t.source_file)
-                defs_by_name.setdefault(t.from_entity, []).append((nid, t.source_file))
+                owner = getattr(t, "owner_class", None)
+                nid = _entity_id(project, t.from_entity, t.source_file, owner)
+                defs_by_name.setdefault(t.from_entity, []).append((nid, t.source_file, owner))
                 if t.from_type == "class":
                     class_file.setdefault(t.from_entity, t.source_file)
 
-        # Pass 2: write nodes/edges with resolved, file-qualified ids.
+        # Pass 2: write nodes/edges with resolved, file+class-qualified ids.
         for triple in triples:
             file_id = file_id_map.get(triple.source_file, "")
-            from_id = _entity_id(project, triple.from_entity, triple.source_file)
+            from_id = _entity_id(project, triple.from_entity, triple.source_file,
+                                 getattr(triple, "owner_class", None))
             to_id = self._resolve_to_id(triple, project, defs_by_name, class_file)
             self.write_code_triple(triple, file_id, project, from_id=from_id, to_id=to_id)
 
@@ -361,6 +373,12 @@ class LocalGraphClient:
         matches.sort(key=lambda n: self.graph.nodes[n].get("file") is None)
 
         if qualifier and matches:
+            # strongest: nodes whose owner class IS the qualifier (Command.invoke)
+            owned = [n for n in matches
+                     if (self.graph.nodes[n].get("owner") or "").lower() == qualifier.lower()]
+            if owned:
+                return owned
+            # next: nodes in the file where class <qualifier> is defined
             cls_files = {
                 a.get("file") for n, a in self.graph.nodes(data=True)
                 if a.get("type") == "Entity" and a.get("entity_type") == "class"
@@ -450,12 +468,14 @@ class LocalGraphClient:
                     visited.add(pred)
                     queue.append((pred, depth + 1))
 
-        # Qualified query (Type.method): also surface the name-only bucket's
-        # direct callers — calls whose receiver couldn't be statically typed
-        # (e.g. `adapter = self.get_adapter(url); adapter.send()`). They MAY hit
-        # this method, so we don't drop them, but flag resolved=False rather than
-        # claim false precision. An unqualified query already includes them.
-        if want_receiver is not None:
+        # Qualified query (Type.method): if we found NO precise caller, fall back
+        # to the name-only bucket — calls whose receiver couldn't be statically
+        # typed (e.g. `adapter = self.get_adapter(url); adapter.send()`). They MAY
+        # hit this method, so we surface them flagged resolved=False rather than
+        # return nothing. We skip this when there's already a precise answer,
+        # because the bucket for a common name (`invoke`) is mostly calls to OTHER
+        # same-named methods and would flood a query that already resolved.
+        if want_receiver is not None and not results:
             method = entity_name.rsplit(".", 1)[1]
             bucket = f"{project}:{method}"
             if bucket in self.graph and bucket not in target_set:

{codecompass_mcp-2.8.0 → codecompass_mcp-3.0.0}/ingestion/code_parser.py

@@ -221,6 +221,7 @@ def _extract_python(root: Node, source: bytes, file_path: str) -> list[CodeTripl
                         source_file=file_path,
                         line_number=_line(node),
                         is_exported=name in exported,
+                        owner_class=_enclosing_python_class(node),
                     ))
 
             case "class_definition":
@@ -308,6 +309,7 @@ def _extract_python(root: Node, source: bytes, file_path: str) -> list[CodeTripl
                         line_number=_line(node),
                         call_receiver=receiver,
                         call_receiver_type=receiver_type,
+                        owner_class=_enclosing_python_class(node) if scope else None,
                     ))
 
     return triples
@@ -630,11 +632,127 @@ def _php_string_text(string_node: Node) -> str:
     return _text(frag) if frag else _text(string_node).strip("'\"")
 
 
+def _php_type_basename(node: Node | None) -> str | None:
+    """Class name from a PHP type node (`named_type`/`type`/`qualified_name`),
+    stripping any namespace. Skips scalar/pseudo types (int, string, void, …)."""
+    if node is None:
+        return None
+    for desc in _walk(node):
+        if desc.type in ("name", "qualified_name"):
+            base = _php_basename(desc)
+            if base and base[:1].isupper():  # PSR class-name convention
+                return base
+    return None
+
+
+def _php_new_type(node: Node | None) -> str | None:
+    """Class name of `new X(...)`, else None."""
+    if node is None or node.type != "object_creation_expression":
+        return None
+    for child in node.children:
+        if child.type in ("name", "qualified_name"):
+            base = _php_basename(child)
+            if base and base.lower() not in _PHP_SELF_REFERENTIAL:
+                return base
+    return None
+
+
+def _php_is_public(method_node: Node) -> bool:
+    """PHP method visibility — public (or no modifier, which defaults public) is
+    API; private/protected is internal. Reads the `visibility_modifier` child."""
+    for child in method_node.children:
+        if child.type == "visibility_modifier":
+            return _text(child).lower() not in ("private", "protected")
+    return True  # PHP methods default to public
+
+
+def _php_return_types(root: Node) -> dict[str, str]:
+    """Map function/method name -> declared return type (`function f(): Foo`)."""
+    rets: dict[str, str] = {}
+    conflict: set[str] = set()
+    for node in _walk(root):
+        if node.type in ("function_definition", "method_declaration"):
+            name = _php_name(node)
+            rt = node.child_by_field_name("return_type")
+            t = _php_type_basename(rt) if rt is not None else None
+            if name and t:
+                if name in rets and rets[name] != t:
+                    conflict.add(name)
+                else:
+                    rets[name] = t
+    for name in conflict:
+        rets.pop(name, None)
+    return rets
+
+
+def _php_type_env(root: Node) -> dict[str, str]:
+    """Best-effort PHP variable → class map (no `$` in keys).
+
+    Binds from `$x = new Foo()`, typed params (`function f(Foo $x)`), and
+    return-type inference (`$x = make()` where `make(): Foo`). Conflicts dropped.
+    """
+    ret_types = _php_return_types(root)
+    types: dict[str, str] = {}
+    ambiguous: set[str] = set()
+
+    def bind(name: str | None, t: str | None) -> None:
+        if not name or not t:
+            return
+        if name in types and types[name] != t:
+            ambiguous.add(name)
+        else:
+            types[name] = t
+
+    for node in _walk(root):
+        if node.type == "assignment_expression" and node.children:
+            lhs = node.children[0]
+            rhs = node.children[-1]
+            if lhs.type == "variable_name":
+                name = _php_var_name(lhs)
+                bind(name, _php_new_type(rhs))
+                if rhs.type in ("function_call_expression", "member_call_expression",
+                                "nullsafe_member_call_expression", "scoped_call_expression"):
+                    callee = _child_of_type(rhs, "name")
+                    if callee is not None:
+                        bind(name, ret_types.get(_text(callee)))
+        elif node.type == "simple_parameter":
+            var = _child_of_type(node, "variable_name")
+            ty = node.child_by_field_name("type")
+            if var is not None and ty is not None:
+                bind(_php_var_name(var), _php_type_basename(ty))
+
+    for name in ambiguous:
+        types.pop(name, None)
+    return types
+
+
+def _php_call_receiver(node: Node, env: dict[str, str]) -> tuple[str | None, str | None]:
+    """Receiver text + inferred type for a member call `$obj->method()`."""
+    obj = node.child_by_field_name("object")
+    if obj is None:
+        obj = node.children[0] if node.children else None
+    if obj is None:
+        return None, None
+    # inline `(new Foo())->m()`
+    nt = _php_new_type(obj)
+    if nt:
+        return "new", nt
+    if obj.type == "variable_name":
+        var = _php_var_name(obj)
+        if var == "this":
+            container = _enclosing_php_container(node)
+            return "this", (container[0] if container else None)
+        return var, env.get(var)
+    return _text(obj), None
+
+
 def _extract_php(root: Node, source: bytes, file_path: str) -> list[CodeTriple]:
     module_name = _module_name_from_path(file_path)
     triples: list[CodeTriple] = []
+    type_env = _php_type_env(root)
 
-    def defined_in(name: str, entity_type: str, line: int) -> None:
+    def defined_in(name: str, entity_type: str, line: int, is_exported: bool = True,
+                   owner: str | None = None) -> None:
         triples.append(CodeTriple(
             from_entity=name,
             from_type=entity_type,
@@ -643,6 +761,8 @@ def _extract_php(root: Node, source: bytes, file_path: str) -> list[CodeTriple]:
             to_type=TYPE_MODULE,
             source_file=file_path,
             line_number=line,
+            is_exported=is_exported,
+            owner_class=owner,
         ))
 
     def inherits(from_name: str, from_type: str, to_node: Node, to_type: str) -> None:
@@ -658,11 +778,13 @@ def _extract_php(root: Node, source: bytes, file_path: str) -> list[CodeTriple]:
                 line_number=_line(to_node),
             ))
 
-    def calls(callee: str, callee_type: str, line: int, scope_node: Node) -> None:
+    def calls(callee: str, callee_type: str, line: int, scope_node: Node,
+              receiver: str | None = None, receiver_type: str | None = None) -> 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)
+        container = _enclosing_php_container(scope_node)
         triples.append(CodeTriple(
             from_entity=caller,
             from_type=caller_type,
@@ -671,6 +793,9 @@ def _extract_php(root: Node, source: bytes, file_path: str) -> list[CodeTriple]:
             to_type=callee_type,
             source_file=file_path,
             line_number=line,
+            call_receiver=receiver,
+            call_receiver_type=receiver_type,
+            owner_class=container[0] if (scope and container) else None,
         ))
 
     for node in _walk(root):
@@ -684,7 +809,9 @@ def _extract_php(root: Node, source: bytes, file_path: str) -> list[CodeTriple]:
             case "method_declaration":
                 name = _php_name(node)
                 if name:
-                    defined_in(name, TYPE_FUNCTION, _line(node))
+                    container = _enclosing_php_container(node)
+                    defined_in(name, TYPE_FUNCTION, _line(node), is_exported=_php_is_public(node),
+                               owner=container[0] if container else None)
 
             case "anonymous_function" | "arrow_function":
                 parent = node.parent
@@ -851,7 +978,9 @@ def _extract_php(root: Node, source: bytes, file_path: str) -> list[CodeTriple]:
             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)
+                    recv, recv_type = _php_call_receiver(node, type_env)
+                    calls(_text(callee_node), TYPE_FUNCTION, _line(node), node,
+                          receiver=recv, receiver_type=recv_type)
 
             case "scoped_call_expression":
                 names = _children_of_type(node, "name")
@@ -886,7 +1015,7 @@ def _extract_javascript(root: Node, source: bytes, file_path: str) -> list[CodeT
     # Best-effort variable → type map for receiver type inference on calls.
     type_env = _js_type_env(root)
 
-    def defined(name: str, line: int) -> None:
+    def defined(name: str, line: int, owner: str | None = None) -> None:
         triples.append(CodeTriple(
             from_entity=name,
             from_type=TYPE_FUNCTION,
@@ -896,6 +1025,7 @@ def _extract_javascript(root: Node, source: bytes, file_path: str) -> list[CodeT
             source_file=file_path,
             line_number=line,
             is_exported=name in exported,
+            owner_class=owner,
         ))
 
     for node in _walk(root):
@@ -908,7 +1038,7 @@ def _extract_javascript(root: Node, source: bytes, file_path: str) -> list[CodeT
             case "method_definition":
                 name_node = _child_of_type(node, "property_identifier")
                 if name_node:
-                    defined(_text(name_node), _line(name_node))
+                    defined(_text(name_node), _line(name_node), owner=_enclosing_class_name(node))
 
             case "variable_declarator":
                 # Capture: const foo = () => ...
@@ -970,6 +1100,7 @@ def _extract_javascript(root: Node, source: bytes, file_path: str) -> list[CodeT
                         line_number=_line(node),
                         call_receiver=receiver,
                         call_receiver_type=receiver_type,
+                        owner_class=_enclosing_class_name(node) if scope else None,
                     ))
 
     return triples

{codecompass_mcp-2.8.0 → codecompass_mcp-3.0.0}/ingestion/hierarchy_builder.py

@@ -20,7 +20,7 @@ _SKIP_DIRS = {
 }
 
 # Supported source file extensions (mirrors code_parser.SUPPORTED_EXTENSIONS)
-_SOURCE_EXTENSIONS = {".py", ".js", ".ts", ".tsx", ".html", ".css", ".scss"}
+_SOURCE_EXTENSIONS = {".py", ".js", ".jsx", ".ts", ".tsx", ".html", ".css", ".scss", ".php"}
 
 
 def build_hierarchy(project_root: str, project_name: str, client) -> dict[str, str]:

{codecompass_mcp-2.8.0 → codecompass_mcp-3.0.0}/models/code_types.py

@@ -33,6 +33,12 @@ class CodeTriple:
     # Lets dead-code analysis avoid flagging intentionally-exported symbols.
     is_exported: bool = False
 
+    # Class that `from_entity` belongs to — the method's class for a definition,
+    # or the caller's class for a call. None for module-level entities. Lets node
+    # ids be class-qualified so same-named methods of different classes in the
+    # SAME file stay distinct (Command.invoke vs Context.invoke in core.py).
+    owner_class: str | None = None
+
 
 @dataclass
 class FileNode:

{codecompass_mcp-2.8.0 → codecompass_mcp-3.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codecompass-mcp"
-version = "2.8.0"
+version = "3.0.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.8.0 → codecompass_mcp-3.0.0}/tests/test_accuracy_fixes.py

@@ -339,6 +339,30 @@ def test_python_public_method_marked_exported():
     assert by_name.get("_private") is False, "underscore method is not exported"
 
 
+def test_php_receiver_type_and_exports():
+    src = (
+        "<?php\n"
+        "class Session {\n"
+        "    public function send($r) { return 1; }\n"
+        "    private function _helper() { return 2; }\n"
+        "    public function getAdapter($u): HTTPAdapter { return new HTTPAdapter(); }\n"
+        "    public function request($m) {\n"
+        "        $adapter = $this->getAdapter($m);\n"
+        "        $this->send($m);\n"
+        "        return $adapter->send($m);\n"
+        "    }\n"
+        "}\n"
+    )
+    triples = _parse(src, suffix=".php")
+    sends = [t for t in triples if t.relation_type == "CALLS" and t.to_entity == "send"]
+    types = {t.call_receiver_type for t in sends}
+    assert "Session" in types, "$this->send() typed by enclosing class"
+    assert "HTTPAdapter" in types, "$adapter->send() typed via getAdapter's return type"
+    by_name = {t.from_entity: t.is_exported for t in triples if t.relation_type == "DEFINED_IN"}
+    assert by_name.get("_helper") is False, "private method is not exported"
+    assert by_name.get("request") is True, "public method is exported"
+
+
 def test_graph_grep_regex():
     triples = [
         CodeTriple("HTTPAdapter", "class", "DEFINED_IN", "m", "module", "adapters.py", 1),