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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecompass-mcp
-Version: 2.2.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
@@ -129,10 +129,10 @@ All commands default to the current directory.
 ### Install
 
 ```bash
-# From the codecompass directory
-pip install -e .
+pip install codecompass-mcp
 ```
 
+
 ### Index a project
 
 ```bash

{codecompass_mcp-2.2.0 → codecompass_mcp-2.4.0}/README.md

@@ -92,10 +92,10 @@ All commands default to the current directory.
 ### Install
 
 ```bash
-# From the codecompass directory
-pip install -e .
+pip install codecompass-mcp
 ```
 
+
 ### Index a project
 
 ```bash

{codecompass_mcp-2.2.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.2.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
@@ -129,10 +129,10 @@ All commands default to the current directory.
 ### Install
 
 ```bash
-# From the codecompass directory
-pip install -e .
+pip install codecompass-mcp
 ```
 
+
 ### Index a project
 
 ```bash

{codecompass_mcp-2.2.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.2.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.2.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.2.0 → codecompass_mcp-2.4.0}/ingestion/chunker.py

@@ -1,5 +1,4 @@
 import re
-import PyPDF2
 
 # Rough approximation: 1 token ≈ 4 characters (standard for English prose/code).
 # Used when a tokeniser library is unavailable.
@@ -10,14 +9,6 @@ def _estimate_tokens(text: str) -> int:
     return max(1, len(text) // _CHARS_PER_TOKEN)
 
 
-def chunk_pdf(filepath: str, tokens_per_chunk: int = 500, overlap_tokens: int = 50) -> list[str]:
-    """Split PDF into overlapping token-sized chunks."""
-    with open(filepath, "rb") as f:
-        reader = PyPDF2.PdfReader(f)
-        full_text = " ".join(page.extract_text() or "" for page in reader.pages)
-    return chunk_text(full_text, tokens_per_chunk=tokens_per_chunk, overlap_tokens=overlap_tokens)
-
-
 def chunk_text(text: str, tokens_per_chunk: int = 500, overlap_tokens: int = 50) -> list[str]:
     """
     Split text into chunks of approximately `tokens_per_chunk` tokens with

{codecompass_mcp-2.2.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.2.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"}
+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-]+)')
@@ -101,6 +118,11 @@ def _load_html_parser() -> tuple[Parser, Language]:
     return _make_parser(tshtml.language)
 
 
+def _load_php_parser() -> tuple[Parser, Language]:
+    import tree_sitter_php as tsphp
+    return _make_parser(tsphp.language_php)
+
+
 def _load_css_parser() -> tuple[Parser, Language]:
     import tree_sitter_css as tscss
     return _make_parser(tscss.language)
@@ -109,11 +131,13 @@ 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,
     ".css":  _load_css_parser,
     ".scss": _load_css_parser,
+    ".php":  _load_php_parser,
 }
 
 
@@ -147,6 +171,15 @@ def _child_of_type(node: Node, type_name: str) -> Node | None:
     return None
 
 
+def _get_node_name(node: Node, types: list[str]) -> str | None:
+    """Try multiple type names to find an identifier/name node."""
+    for t in types:
+        found = _child_of_type(node, t)
+        if found:
+            return _text(found)
+    return None
+
+
 def _children_of_type(node: Node, type_name: str) -> list[Node]:
     return [c for c in node.children if c.type == type_name]
 
@@ -174,23 +207,23 @@ def _extract_python(root: Node, source: bytes, file_path: str) -> list[CodeTripl
     for node in _walk(root):
         match node.type:
             case "function_definition":
-                name_node = _child_of_type(node, "identifier")
-                if name_node:
+                name = _get_node_name(node, ["identifier"])
+                if name:
                     triples.append(CodeTriple(
-                        from_entity=_text(name_node),
+                        from_entity=name,
                         from_type=TYPE_FUNCTION,
                         relation_type=DEFINED_IN,
                         to_entity=module_name,
                         to_type=TYPE_MODULE,
                         source_file=file_path,
-                        line_number=_line(name_node),
+                        line_number=_line(node),
                     ))
 
             case "class_definition":
-                name_node = _child_of_type(node, "identifier")
-                if not name_node:
+                name = _get_node_name(node, ["identifier"])
+                if not name:
                     continue
-                class_name = _text(name_node)
+                class_name = name
 
                 # Extract base classes from argument_list
                 arg_list = _child_of_type(node, "argument_list")
@@ -203,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":
@@ -281,6 +314,370 @@ def _extract_python_callee(call_node: Node) -> str | None:
     return 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 = _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_CONSTANT,
+                        relation_type=DEFINED_IN,
+                        to_entity=container_name,
+                        to_type=container_type,
+                        source_file=file_path,
+                        line_number=_line(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=container_name,
+                            from_type=container_type,
+                            relation_type=INHERITS,
+                            to_entity=_text(target),
+                            to_type=TYPE_TRAIT,
+                            source_file=file_path,
+                            line_number=_line(target),
+                        ))
+
+            # -- Namespace imports -----------------------------------------
+            case "namespace_use_declaration":
+                for dotted, target_node in _extract_php_namespace_use(node):
+                    triples.append(CodeTriple(
+                        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(target_node),
+                    ))
+
+            # -- 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)
+
+            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
 # ---------------------------------------------------------------------------
@@ -642,11 +1039,13 @@ 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,
     ".css":  _extract_css,
     ".scss": _extract_css,
+    ".php":  _extract_php,
 }
 
 

{codecompass_mcp-2.2.0 → codecompass_mcp-2.4.0}/ingestion/entity_resolver.py

@@ -23,7 +23,7 @@ Return ONLY valid JSON, no other text:
 If no clear duplicates exist, return {"groups": []}"""
 
 
-def resolve_entities(client, dry_run: bool = False) -> int:
+def resolve_entities(client) -> int:
     """Identify and merge duplicate entity nodes in the local graph."""
     all_nodes = [
         {"id": n, "name": attr.get("name", n), "type": attr.get("entity_type", "")}
@@ -79,20 +79,18 @@ def resolve_entities(client, dry_run: bool = False) -> int:
             dup_node = name_to_node.get(dup_name)
             if not dup_node or dup_node["id"] == canonical_node["id"]:
                 continue
-            tag = "[dry-run] " if dry_run else ""
-            print(f"  {tag}'{dup_name}'  →  '{canonical_name}'")
-            if not dry_run:
-                # Remap all edges from duplicate to canonical
-                dup_id = dup_node["id"]
-                canon_id = canonical_node["id"]
-                for pred in list(client.graph.predecessors(dup_id)):
-                    for key, data in list(client.graph.get_edge_data(pred, dup_id).items()):
-                        client.graph.add_edge(pred, canon_id, **data)
-                for succ in list(client.graph.successors(dup_id)):
-                    for key, data in list(client.graph.get_edge_data(dup_id, succ).items()):
-                        client.graph.add_edge(canon_id, succ, **data)
-                client.graph.remove_node(dup_id)
-                merged_count += 1
+            print(f"  '{dup_name}'  →  '{canonical_name}'")
+            # Remap all edges from duplicate to canonical
+            dup_id = dup_node["id"]
+            canon_id = canonical_node["id"]
+            for pred in list(client.graph.predecessors(dup_id)):
+                for key, data in list(client.graph.get_edge_data(pred, dup_id).items()):
+                    client.graph.add_edge(pred, canon_id, **data)
+            for succ in list(client.graph.successors(dup_id)):
+                for key, data in list(client.graph.get_edge_data(dup_id, succ).items()):
+                    client.graph.add_edge(canon_id, succ, **data)
+            client.graph.remove_node(dup_id)
+            merged_count += 1
 
     if merged_count:
         client.save()

{codecompass_mcp-2.2.0 → codecompass_mcp-2.4.0}/ingestion/reader_agent.py

@@ -58,9 +58,10 @@ def _extract_triples_sync(chunk: str) -> list[Triple]:
     )
 
     try:
-        raw = response.content[0].text
-        raw = re.sub(r"^```[a-z]*\n?", "", raw.strip(), flags=re.MULTILINE)
-        raw = re.sub(r"```$", "", raw.strip(), flags=re.MULTILINE)
+        raw = response.content[0].text.strip()
+        if raw.startswith("```"):
+            raw = re.sub(r"^```[a-z]*\n?", "", raw)
+            raw = re.sub(r"```$", "", raw)
         data = json.loads(raw.strip())
     except (json.JSONDecodeError, IndexError) as e:
         print(f"[reader_agent] JSON parse failed: {e} | raw: {raw[:200]!r}")

{codecompass_mcp-2.2.0 → codecompass_mcp-2.4.0}/main.py

@@ -23,6 +23,10 @@ console = Console()
 
 _CODECOMPASS_START = "<!-- codecompass-code-graph-start -->"
 _CODECOMPASS_END = "<!-- codecompass-code-graph-end -->"
+_CODECOMPASS_READ_INSTRUCTION = (
+    "Read `.codecompass` before making any changes or before reading any file. "
+    "If you think codecompass will help in any way, use it."
+)
 
 
 def init_project(repo_path: str) -> None:
@@ -69,6 +73,20 @@ def init_project(repo_path: str) -> None:
             with open(file_path, "w") as f:
                 f.write(content)
 
+    # ponytail: minimal way to create claude.md in repo root
+    claude_md_path = os.path.join(repo_path, "claude.md")
+    if not os.path.exists(claude_md_path):
+        with open(claude_md_path, "w") as f:
+            f.write(f"AGENTS.md\n\n{_CODECOMPASS_READ_INSTRUCTION}\n")
+    else:
+        with open(claude_md_path) as f:
+            claude_md_content = f.read()
+        if _CODECOMPASS_READ_INSTRUCTION not in claude_md_content:
+            with open(claude_md_path, "a") as f:
+                if claude_md_content and not claude_md_content.endswith("\n"):
+                    f.write("\n")
+                f.write(f"\n{_CODECOMPASS_READ_INSTRUCTION}\n")
+
     _ensure_gitignore(repo_path)
     console.print(f"[bold green]Initialized CodeCompass in:[/] {compass_dir}")
     _register_project_agents_md(repo_path)
@@ -173,6 +191,8 @@ def _register_project_agents_md(repo_path: str) -> None:
     block = f"""{_CODECOMPASS_START}
 ## Code graph
 
+**{_CODECOMPASS_READ_INSTRUCTION}**
+
 This project has a CodeCompass code knowledge graph at `.codecompass/graph.json`.
 Every node carries `kind` (e.g. `function:python`, `class:typescript`) and a
 human-readable `description`. Use it as your primary navigation tool.

{codecompass_mcp-2.2.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.2.0 → codecompass_mcp-2.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codecompass-mcp"
-version = "2.2.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