coderay 1.0.7__tar.gz → 1.0.8__tar.gz

{coderay-1.0.7/src/coderay.egg-info → coderay-1.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coderay
-Version: 1.0.7
+Version: 1.0.8
 Summary: X-ray your codebase — semantic search, code graphs, file skeletons, and MCP server
 Author-email: Bogdan Copocean <bogdancopocean@gmail.com>
 License-Expression: MIT
@@ -119,7 +119,10 @@ Add to `~/.claude/claude_code_config.json` or Cursor MCP settings:
   "mcpServers": {
     "coderay": {
       "command": "/path/to/your/.venv/bin/coderay-mcp",
-      "args": []
+      "args": [],
+      "env": {
+        "CODERAY_INDEX_DIR": "${workspaceFolder}/.index"
+      }
     }
   }
 }
@@ -127,6 +130,10 @@ Add to `~/.claude/claude_code_config.json` or Cursor MCP settings:
 
 Replace `/path/to/your/.venv/bin/coderay-mcp` with the output of `which coderay-mcp`.
 
+**Important:** Set `CODERAY_INDEX_DIR` so the MCP server finds the index and graph
+in your project. Cursor interpolates `${workspaceFolder}` to the workspace root.
+Run `coderay build` (or `coderay watch`) from the project root first.
+
 ## CLI reference
 
 | Command | Description |

{coderay-1.0.7 → coderay-1.0.8}/README.md

@@ -70,7 +70,10 @@ Add to `~/.claude/claude_code_config.json` or Cursor MCP settings:
   "mcpServers": {
     "coderay": {
       "command": "/path/to/your/.venv/bin/coderay-mcp",
-      "args": []
+      "args": [],
+      "env": {
+        "CODERAY_INDEX_DIR": "${workspaceFolder}/.index"
+      }
     }
   }
 }
@@ -78,6 +81,10 @@ Add to `~/.claude/claude_code_config.json` or Cursor MCP settings:
 
 Replace `/path/to/your/.venv/bin/coderay-mcp` with the output of `which coderay-mcp`.
 
+**Important:** Set `CODERAY_INDEX_DIR` so the MCP server finds the index and graph
+in your project. Cursor interpolates `${workspaceFolder}` to the workspace root.
+Run `coderay build` (or `coderay watch`) from the project root first.
+
 ## CLI reference
 
 | Command | Description |

{coderay-1.0.7 → coderay-1.0.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "coderay"
-version = "1.0.7"
+version = "1.0.8"
 description = "X-ray your codebase — semantic search, code graphs, file skeletons, and MCP server"
 readme = "README.md"
 license = "MIT"

coderay-1.0.8/src/coderay/graph/_handlers/__init__.py

@@ -0,0 +1,21 @@
+"""Handler mixins for graph extraction.
+
+Each mixin provides handlers for a specific AST node category. The main
+parser (GraphTreeSitterParser) composes them via multiple inheritance.
+Mixin order: Import, TypeResolution, Definition, Assignment, Call, BaseParser.
+TypeResolution must come before Definition and Assignment (they use its methods).
+"""
+
+from coderay.graph._handlers.assignments import AssignmentHandlerMixin
+from coderay.graph._handlers.calls import CallHandlerMixin
+from coderay.graph._handlers.definitions import DefinitionHandlerMixin
+from coderay.graph._handlers.imports import ImportHandlerMixin
+from coderay.graph._handlers.type_resolution import TypeResolutionMixin
+
+__all__ = [
+    "AssignmentHandlerMixin",
+    "CallHandlerMixin",
+    "DefinitionHandlerMixin",
+    "ImportHandlerMixin",
+    "TypeResolutionMixin",
+]

coderay-1.0.8/src/coderay/graph/_handlers/assignments.py

@@ -0,0 +1,192 @@
+"""Assignment and with-statement handling for graph extraction.
+
+Tracks variable bindings so later calls resolve correctly:
+- x = y → alias (y.resolve() used when x is called)
+- x = obj.attr → alias when obj resolves
+- x = factory() → instance from factory's return type
+- self.attr = param → instance from param's type hint (injection)
+- with cm() as x → instance from cm.__enter__ return type
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+TSNode = Any
+
+
+class AssignmentHandlerMixin:
+    """Handles assignments and with statements for instance/alias tracking."""
+
+    def _handle_assignment(self, node: TSNode, *, scope_stack: list[str]) -> None:
+        """Track aliases and instance types for call resolution.
+
+        Handles: alias (x = y), attribute alias (x = obj.attr), factory
+        return type (x = factory()), constructor/setter injection (self.attr = param).
+        """
+        children = node.children
+        if len(children) < 3:
+            return  # Need at least: target, "=", value
+
+        lhs = children[0]
+        rhs = children[-1]  # [-1] handles "x: int = 5" (annotated)
+
+        # Constructor/setter injection: self.storage = storage (storage: StoragePort)
+        if lhs.type == "attribute" and rhs.type == "identifier":
+            lhs_text = self.node_text(lhs)
+            if lhs_text.startswith(("self.", "this.")):
+                rhs_name = self.node_text(rhs)
+                func_node = self._get_enclosing_function_node(node)
+                if func_node:
+                    type_hint = self._get_parameter_type_hint(func_node, rhs_name)
+                    if type_hint:
+                        self._file_ctx.register_instance(lhs_text, type_hint)
+                        class_qualified = self._find_enclosing_class_from_node(
+                            func_node
+                        )
+                        if class_qualified:
+                            attr_name = lhs_text.split(".", 1)[1].split(".")[0]
+                            self._file_ctx.register_class_attribute(
+                                class_qualified, attr_name, type_hint
+                            )
+            return
+
+        # Tuple unpacking: a, b = get_pair()
+        if lhs.type in ("pattern_list", "tuple_pattern", "list_pattern"):
+            self._handle_tuple_unpacking(lhs, rhs)
+            return
+
+        if lhs.type != "identifier":
+            return
+
+        lhs_name = self.node_text(lhs)
+
+        if rhs.type == "identifier":
+            # Simple alias: my_func = imported_func
+            rhs_name = self.node_text(rhs)
+            resolved = self._file_ctx.resolve(rhs_name)
+            if resolved:
+                self._file_ctx.register_alias(lhs_name, resolved)
+        elif rhs.type == "attribute":
+            # x = obj.attr: alias when obj resolves (e.g. path_func = Path)
+            rhs_text = self.node_text(rhs)
+            parts = rhs_text.split(".")
+            if len(parts) == 2:
+                prefix, attr = parts
+                prefix_resolved = self._file_ctx.resolve(prefix)
+                if prefix_resolved:
+                    self._file_ctx.register_alias(
+                        lhs_name, f"{prefix_resolved}::{attr}"
+                    )
+        elif rhs.type in self._ctx.lang_cfg.graph.call_types:
+            # functools.partial: p = partial(foo, 1); p() → alias to foo
+            callee_node = rhs.child_by_field_name("function")
+            if callee_node:
+                callee_name = self.node_text(callee_node).strip()
+                if callee_name:
+                    if callee_name == "partial" or callee_name.endswith(".partial"):
+                        first_arg = self._get_first_call_arg(rhs)
+                        if first_arg:
+                            resolved = self._file_ctx.resolve(first_arg)
+                            if resolved:
+                                self._file_ctx.register_alias(lhs_name, resolved)
+                        return
+                    return_type = self._get_function_return_type(callee_name)
+                    if return_type:
+                        self._file_ctx.register_instance(lhs_name, return_type)
+
+    def _handle_with_statement(self, node: TSNode, *, scope_stack: list[str]) -> None:
+        """Track ``with cm() as var:`` — register var with __enter__ return type."""
+        for child in node.children:
+            if child.type in ("with_clause", "with_clauses"):
+                for item in child.children:
+                    if item.type == "with_item":
+                        self._process_with_item(item)
+
+    def _process_with_item(self, item: TSNode) -> None:
+        """Register the ``as`` target with the context manager's __enter__ type."""
+        value = item.child_by_field_name("value")
+        if not value:
+            return
+        # with x as y: value is as_pattern with alias; with x(): value is call
+        if value.type == "as_pattern":
+            target_node = value.child_by_field_name("alias")
+            call_node = next(
+                (
+                    c
+                    for c in value.named_children
+                    if c.type in self._ctx.lang_cfg.graph.call_types
+                ),
+                None,
+            )
+        else:
+            # with x(): no "as" target — we don't register
+            target_node = value if value.type == "as_pattern_target" else None
+            call_node = (
+                value if value.type in self._ctx.lang_cfg.graph.call_types else None
+            )
+        if not call_node or not target_node:
+            return
+        var_name = self.node_text(target_node)
+        if not var_name or var_name == "_":
+            return
+        callee_node = call_node.child_by_field_name("function")
+        cm_name = self.node_text(callee_node).strip() if callee_node else ""
+        if not cm_name:
+            return
+        enter_return = self._get_function_return_type(f"{cm_name}.__enter__")
+        if enter_return:
+            self._file_ctx.register_instance(var_name, enter_return)
+
+    def _handle_tuple_unpacking(self, lhs: TSNode, rhs: TSNode) -> None:
+        """Track a, b = func() — register each unpacked name from return type."""
+        # Collect identifiers from pattern_list
+        identifiers: list[str] = []
+        for child in lhs.children:
+            if child.type == "identifier":
+                name = self.node_text(child)
+                if name and name != "_":
+                    identifiers.append(name)
+        if not identifiers:
+            return
+
+        # RHS must be a call
+        if rhs.type not in self._ctx.lang_cfg.graph.call_types:
+            return
+        callee_node = rhs.child_by_field_name("function")
+        if not callee_node:
+            return
+        callee_name = self.node_text(callee_node).strip()
+        if not callee_name:
+            return
+
+        # Get raw type text from function definition
+        func_node = (
+            self._find_method_in_class(*callee_name.split(".", 1))
+            if "." in callee_name
+            else self._find_top_level_function(callee_name)
+        )
+        if not func_node:
+            return
+        type_node = func_node.child_by_field_name(
+            "return_type"
+        ) or func_node.child_by_field_name("type")
+        if not type_node:
+            return
+
+        type_args = self._extract_tuple_type_args(type_node)
+        for i, name in enumerate(identifiers):
+            if i < len(type_args):
+                self._file_ctx.register_alias(name, type_args[i])
+
+    def _get_first_call_arg(self, call_node: TSNode) -> str | None:
+        """Extract the first argument identifier from a call (e.g. partial(foo, 1))."""
+        arg_list = call_node.child_by_field_name("arguments") or next(
+            (c for c in call_node.children if c.type == "argument_list"), None
+        )
+        if not arg_list:
+            return None
+        for child in arg_list.named_children:
+            if child.type in ("identifier", "dotted_name", "attribute"):
+                return self.node_text(child)
+        return None

coderay-1.0.8/src/coderay/graph/_handlers/calls.py

@@ -0,0 +1,277 @@
+"""Call handling for graph extraction.
+
+Creates CALLS edges (caller -> callee) from resolved call expressions.
+Resolves callees via FileContext (instance tracking, aliases, class attrs).
+Also tracks x = SomeClass() for instantiation. Filters out builtins and
+excluded modules.
+"""
+
+from __future__ import annotations
+
+import builtins
+from typing import Any
+
+from coderay.core.models import EdgeKind, GraphEdge
+from coderay.parsing.languages import get_supported_extensions
+
+TSNode = Any
+
+# Builtins (print, len, etc.) are filtered from CALLS edges
+_PYTHON_BUILTINS: frozenset[str] = frozenset(
+    name for name in dir(builtins) if not name.startswith("_")
+)
+
+
+class CallHandlerMixin:
+    """Handles call expressions: CALLS edges and instantiation tracking."""
+
+    def _caller_id_from_scope(self, scope_stack: list[str]) -> str:
+        """Return the caller node ID for the given scope stack."""
+        if scope_stack:
+            return f"{self.file_path}::{'.'.join(scope_stack)}"
+        return self._module_id
+
+    def _handle_call(self, node: TSNode, *, scope_stack: list[str]) -> None:
+        """Create a CALLS edge from the enclosing scope to the resolved callee."""
+        caller_id = self._caller_id_from_scope(scope_stack)
+
+        callee_node = node.child_by_field_name("function")
+        if callee_node is None:
+            return
+        raw_callee = self.node_text(callee_node)
+        if not raw_callee:
+            return
+
+        callee_targets = self._resolve_callee_targets(raw_callee, scope_stack)
+
+        for callee_name in callee_targets:
+            if self._is_excluded(callee_name, raw_callee):
+                continue
+            if callee_name:
+                self._edges.append(
+                    GraphEdge(
+                        source=caller_id,
+                        target=callee_name,
+                        kind=EdgeKind.CALLS,
+                    )
+                )
+
+        self._maybe_track_instantiation(node, raw_callee)
+
+    def _resolve_callee_targets(self, raw: str, scope_stack: list[str]) -> list[str]:
+        """Resolve a callee expression to a qualified target for CALLS edges."""
+        result = self._resolve_super_targets(raw, scope_stack)
+        if result is not None:
+            return result
+        result = self._resolve_self_targets(raw, scope_stack)
+        if result is not None:
+            return result
+        parts = raw.split(".")
+        if len(parts) == 1:
+            return self._resolve_simple_name_targets(raw)
+        return self._resolve_chain_targets(raw)
+
+    def _resolve_super_targets(
+        self, raw: str, scope_stack: list[str]
+    ) -> list[str] | None:
+        """Resolve super().method() to parent class method."""
+        if not raw.startswith("super()."):
+            return None
+        method = raw[len("super().") :]
+        parent_target = self._resolve_super_call(scope_stack, method)
+        return [parent_target] if parent_target else [method]
+
+    def _resolve_self_targets(
+        self, raw: str, scope_stack: list[str]
+    ) -> list[str] | None:
+        """Resolve self.method() or self.attr.method() via instance/class attrs."""
+        if not raw.startswith(("self.", "this.")):
+            return None
+        suffix = raw.split(".", 1)[1]
+        parts = suffix.split(".")
+        method = parts[-1]
+
+        if len(parts) == 1:
+            class_qualified = self._find_enclosing_class(scope_stack)
+            if class_qualified:
+                return [f"{self.file_path}::{class_qualified}.{method}"]
+
+        prefix = "self." if raw.startswith("self.") else "this."
+        instance_key = prefix + ".".join(parts[:-1])
+        class_ref = self._file_ctx.resolve_instance(instance_key)
+        if not class_ref:
+            class_qualified = self._find_enclosing_class(scope_stack)
+            if class_qualified and len(parts) == 2:
+                attr_name = parts[0]
+                class_ref = self._file_ctx.resolve_class_attribute(
+                    class_qualified, attr_name
+                )
+        if class_ref:
+            return [f"{class_ref}.{method}"]
+        return [method]
+
+    def _resolve_simple_name_targets(self, raw: str) -> list[str]:
+        """Resolve simple name func() or obj() via alias/import/instance."""
+        name = raw
+        instance_class = self._file_ctx.resolve_instance(name)
+        if instance_class:
+            return [f"{instance_class}.__call__"]
+        resolved = self._file_ctx.resolve(name)
+        return [resolved] if resolved else [name]
+
+    def _resolve_chain_targets(self, raw: str) -> list[str]:
+        """Resolve obj.method(), obj.attr.method(), or obj.attr() chains."""
+        parts = raw.split(".")
+        obj_name = parts[0]
+        method_name = parts[-1]
+
+        if len(parts) > 2:
+            chain = ".".join(parts[:-1])
+            chain_refs = self._file_ctx.resolve_chain(chain)
+            if chain_refs:
+                return [f"{ref}.{method_name}" for ref in chain_refs]
+
+        method_targets = self._file_ctx.resolve_method_calls(obj_name, method_name)
+        if method_targets:
+            return method_targets
+
+        obj_resolved = self._file_ctx.resolve(obj_name)
+        if obj_resolved:
+            tail = ".".join(parts[1:])
+            _, ext = obj_resolved.rsplit(".", 1) if "." in obj_resolved else ("", "")
+            supported = get_supported_extensions()
+            if ext and f".{ext}" in supported:
+                return [f"{obj_resolved}::{tail}"]
+            return [f"{obj_resolved}.{tail}"]
+
+        return [method_name]
+
+    def _is_excluded(self, resolved: str, raw: str) -> bool:
+        """Check whether a resolved callee belongs to an excluded module."""
+        # Excluded: typing, abc, __future__; also bare builtins (print, len)
+        if "::" in resolved:
+            module_part = resolved.split("::")[0]
+            if module_part in self._excluded_modules:
+                return True
+        bare = raw.rsplit(".", 1)[-1]
+        return resolved == bare and bare in _PYTHON_BUILTINS
+
+    def _resolve_super_call(self, scope_stack: list[str], method: str) -> str | None:
+        """Resolve super().method() to the parent class's method."""
+        class_qualified = self._find_enclosing_class(scope_stack)
+        if not class_qualified:
+            return None
+        # Find the class node and its first base class
+        base_name = self._get_first_base_class(class_qualified)
+        if not base_name:
+            return None
+        base_resolved = self._file_ctx.resolve(base_name)
+        if not base_resolved:
+            base_resolved = f"{self.file_path}::{base_name}"
+        return f"{base_resolved}.{method}"
+
+    def _get_first_base_class(self, class_qualified: str) -> str | None:
+        """Get the first base class name for a class in the current file."""
+        tree = self.get_tree()
+        target_class = class_qualified.split(".")[-1]
+
+        for node in tree.root_node.children:
+            if node.type not in self._ctx.lang_cfg.class_scope_types:
+                continue
+            name_node = node.child_by_field_name("name") or (
+                node.named_children[0] if node.named_children else None
+            )
+            if not name_node or self.node_text(name_node) != target_class:
+                continue
+            for child in node.children:
+                if child.type not in ("argument_list", "superclass", "extends_clause"):
+                    continue
+                bases = self._get_base_classes_from_arg_list(child)
+                if bases:
+                    return bases[0]
+            break
+        return None
+
+    def _find_enclosing_class(self, scope_stack: list[str]) -> str | None:
+        """Find the innermost enclosing class name from the scope stack.
+
+        scope_stack = ["Outer", "Inner", "method"] → "Outer.Inner"
+        """
+        for i in range(len(scope_stack) - 1, -1, -1):
+            if self._file_ctx.is_class(scope_stack[i]):
+                return ".".join(scope_stack[: i + 1])
+        return None
+
+    def _maybe_track_instantiation(self, call_node: TSNode, raw_callee: str) -> None:
+        """Track ``x = SomeClass()`` or ``self.attr = SomeClass()`` as instance.
+
+        Called after _handle_call; checks if this call is the RHS of an
+        assignment. If so, registers the LHS as an instance of the callee.
+        """
+        parent = call_node.parent
+        if parent is None or parent.type != "assignment":
+            return  # Not an assignment RHS
+
+        lhs = parent.children[0] if parent.children else None
+        if lhs is None:
+            return
+
+        if lhs.type == "identifier":
+            var_name = self.node_text(lhs)
+        elif lhs.type == "attribute":
+            var_name = self.node_text(lhs)
+            if not var_name.startswith(("self.", "this.")):
+                return  # Only track self.attr = X(), not other.attr = X()
+        else:
+            return
+
+        callee_base = raw_callee.rsplit(".", 1)[-1]  # "ApiClient.create" → "create"
+        if not callee_base:
+            return
+
+        resolved = self._file_ctx.resolve(callee_base)
+        is_known_class = self._file_ctx.is_class(callee_base)
+        is_likely_class = bool(callee_base[0].isupper() and resolved is not None)
+
+        # Only register if this looks like a class instantiation
+        if is_known_class or is_likely_class:
+            self._file_ctx.register_instance(var_name, resolved or callee_base)
+            # Also register for class (enables service.client.get resolution)
+            if var_name.startswith(("self.", "this.")):
+                func_node = self._get_enclosing_function_node(call_node)
+                if func_node:
+                    class_qualified = self._find_enclosing_class_from_node(func_node)
+                    if class_qualified:
+                        attr_name = var_name.split(".", 1)[1].split(".")[0]
+                        self._file_ctx.register_class_attribute(
+                            class_qualified, attr_name, resolved or callee_base
+                        )
+
+    def _handle_decorator(self, node: TSNode, *, scope_stack: list[str]) -> None:
+        """Create a CALLS edge from the enclosing scope to the decorator target.
+
+        @my_decorator and @my_decorator() both imply a call at definition time.
+        """
+        text = self.node_text(node).strip()
+        if not text or not text.startswith("@"):
+            return
+        # Strip @ and any trailing call parens: @foo.bar(args) -> foo.bar
+        target_raw = text[1:].strip()
+        if "(" in target_raw:
+            target_raw = target_raw[: target_raw.index("(")].strip()
+        if not target_raw:
+            return
+
+        callee_targets = self._resolve_callee_targets(target_raw, scope_stack)
+        caller_id = self._caller_id_from_scope(scope_stack)
+        for callee_name in callee_targets:
+            if self._is_excluded(callee_name, target_raw):
+                continue
+            if callee_name:
+                self._edges.append(
+                    GraphEdge(
+                        source=caller_id,
+                        target=callee_name,
+                        kind=EdgeKind.CALLS,
+                    )
+                )