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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codecompass-mcp
-Version: 2.2.0
+Version: 2.3.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.3.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.3.0}/ingestion/code_parser.py

@@ -21,7 +21,7 @@ from models.code_types import CodeTriple
 # Constants
 # ---------------------------------------------------------------------------
 
-SUPPORTED_EXTENSIONS = {".py", ".js", ".ts", ".tsx", ".html", ".css", ".scss"}
+SUPPORTED_EXTENSIONS = {".py", ".js", ".ts", ".tsx", ".html", ".css", ".scss", ".php"}
 
 # Relation types
 DEFINED_IN = "DEFINED_IN"
@@ -101,6 +101,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)
+
+
 def _load_css_parser() -> tuple[Parser, Language]:
     import tree_sitter_css as tscss
     return _make_parser(tscss.language)
@@ -114,6 +119,7 @@ _PARSER_LOADERS: dict[str, Callable[[], tuple[Parser, Language]]] = {
     ".html": _load_html_parser,
     ".css":  _load_css_parser,
     ".scss": _load_css_parser,
+    ".php":  _load_php_parser,
 }
 
 
@@ -147,6 +153,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 +189,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")
@@ -281,6 +296,72 @@ def _extract_python_callee(call_node: Node) -> str | None:
     return None
 
 
+# ---------------------------------------------------------------------------
+# PHP extraction
+# ---------------------------------------------------------------------------
+
+def _extract_php(root: Node, source: bytes, file_path: str) -> list[CodeTriple]:
+    module_name = _module_name_from_path(file_path)
+    triples: list[CodeTriple] = []
+
+    for node in _walk(root):
+        match node.type:
+            case "function_definition":
+                name = _get_node_name(node, ["function_name", "identifier"])
+                if name:
+                    triples.append(CodeTriple(
+                        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(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:
+                        triples.append(CodeTriple(
+                            from_entity=class_name,
+                            from_type=TYPE_CLASS,
+                            relation_type=INHERITS,
+                            to_entity=_text(base_node),
+                            to_type=TYPE_CLASS,
+                            source_file=file_path,
+                            line_number=_line(base_node),
+                        ))
+
+            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
+                    triples.append(CodeTriple(
+                        from_entity=caller,
+                        from_type=caller_type,
+                        relation_type=CALLS,
+                        to_entity=callee,
+                        to_type=TYPE_FUNCTION,
+                        source_file=file_path,
+                        line_number=_line(node),
+                    ))
+
+    return triples
+
+
+def _extract_php_callee(call_node: Node) -> str | None:
+    return _get_node_name(call_node, ["function_name", "identifier"])
+
 # ---------------------------------------------------------------------------
 # JavaScript / TypeScript extraction
 # ---------------------------------------------------------------------------
@@ -647,6 +728,7 @@ _EXTRACTORS: dict[str, Callable] = {
     ".html": _extract_html,
     ".css":  _extract_css,
     ".scss": _extract_css,
+    ".php":  _extract_php,
 }
 
 

{codecompass_mcp-2.2.0 → codecompass_mcp-2.3.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.3.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.3.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.3.0}/pyproject.toml

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