context-mcp-server 1.1.0 → 1.1.1

package/codegraph/extractors/ast_extractor.py

@@ -282,18 +282,24 @@ def _extract_with_treesitter(source: bytes, rel_path: str, cfg: dict) -> list[di
 
     nodes: list[dict] = []
     seen:  set[str]   = set()
+    node_by_name: dict[str, dict] = {}
 
-    def _add(name: str, ntype: str, line: int):
+    def _add(name: str, ntype: str, line: int) -> dict | None:
         if not name or name in seen:
-            return
+            return None
         seen.add(name)
-        nodes.append({
-            "id":   f"{rel_path}::{ntype}::{name}",
-            "name": name,
-            "type": ntype,
-            "file": rel_path,
-            "line": line + 1,
-        })
+        entry = {
+            "id":      f"{rel_path}::{ntype}::{name}",
+            "name":    name,
+            "type":    ntype,
+            "file":    rel_path,
+            "line":    line + 1,
+            "calls":   [],
+            "imports": [],
+        }
+        nodes.append(entry)
+        node_by_name[name] = entry
+        return entry
 
     for node in _walk(root, cfg["function_types"]):
         name = _get_name(node, cfg["name_field"])
@@ -305,6 +311,30 @@ def _extract_with_treesitter(source: bytes, rel_path: str, cfg: dict) -> list[di
         if name:
             _add(name, "class", node.start_point[0])
 
+    # Associate call expressions with their enclosing function
+    for node in _walk(root, cfg["call_types"]):
+        callee = _get_call_name(node, cfg["call_field"])
+        if not callee:
+            continue
+        enclosing = _find_enclosing_function(node, cfg["function_types"], cfg["name_field"])
+        if enclosing and enclosing in node_by_name:
+            calls_list = node_by_name[enclosing]["calls"]
+            if callee not in calls_list:
+                calls_list.append(callee)
+
+    # Collect file-level imports and attach to every node in this file
+    import_names: list[str] = []
+    for node in _walk(root, cfg["import_types"]):
+        text = node.text.decode("utf-8", errors="ignore").strip()
+        m = re.match(r'(?:import|from)\s+([\w./"\']+)', text)
+        if m:
+            raw = m.group(1).strip("\"'").split(".")[0].split("/")[-1]
+            if raw and raw not in import_names:
+                import_names.append(raw)
+    if import_names:
+        for entry in nodes:
+            entry["imports"] = import_names[:]
+
     return nodes
 
 
@@ -382,16 +412,106 @@ _EXT_TO_LANG_NAME: dict[str, str] = {
 }
 
 
+# Generic call pattern: word immediately followed by (
+_CALL_RE = re.compile(r'\b([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(')
+
+# Language-specific import patterns (group 1 or 2 = module name)
+_IMPORT_RE: dict[str, re.Pattern] = {
+    "javascript": re.compile(
+        r'(?:import\s+[\s\S]*?from\s+["\']([^"\']+)["\']'
+        r'|require\s*\(\s*["\']([^"\']+)["\']\s*\))',
+        re.MULTILINE,
+    ),
+    "typescript": re.compile(
+        r'(?:import\s+[\s\S]*?from\s+["\']([^"\']+)["\']'
+        r'|require\s*\(\s*["\']([^"\']+)["\']\s*\))',
+        re.MULTILINE,
+    ),
+    "python": re.compile(
+        r'^\s*(?:import\s+([\w.]+)|from\s+([\w.]+)\s+import)',
+        re.MULTILINE,
+    ),
+    "go": re.compile(r'"([^"]+)"', re.MULTILINE),
+    "rust": re.compile(r'use\s+([\w:]+)', re.MULTILINE),
+    "java": re.compile(r'import\s+([\w.]+)', re.MULTILINE),
+    "csharp": re.compile(r'using\s+([\w.]+)', re.MULTILINE),
+}
+
+# Keywords that look like calls but aren't
+_KEYWORD_BLACKLIST = {
+    "if", "for", "while", "switch", "catch", "function", "class",
+    "return", "typeof", "instanceof", "new", "await", "async",
+    "import", "export", "from", "let", "const", "var",
+}
+
+
+def _collect_imports_regex(source: str, lang: str) -> list[str]:
+    pat = _IMPORT_RE.get(lang)
+    if not pat:
+        return []
+    names: list[str] = []
+    seen: set[str] = set()
+    for m in pat.finditer(source):
+        raw = next((g for g in m.groups() if g), None)
+        if not raw:
+            continue
+        # Keep only the last path component / first dotted segment
+        stem = raw.replace("\\", "/").split("/")[-1].split(".")[0].strip("'\"")
+        if stem and stem not in seen:
+            seen.add(stem)
+            names.append(stem)
+    return names
+
+
+def _attach_calls_brace(lines: list[str], func_nodes: list[dict]) -> None:
+    """Brace-count scope tracker: assign call-expression names to enclosing function."""
+    # Sort functions by line
+    funcs = sorted(func_nodes, key=lambda n: n["line"])
+    if not funcs:
+        return
+
+    # Stack: list of (func_node, brace_depth_at_entry)
+    stack: list[tuple[dict, int]] = []
+    depth = 0
+    func_idx = 0
+
+    for line_no, line in enumerate(lines, 1):
+        # Push any functions that start on this line
+        while func_idx < len(funcs) and funcs[func_idx]["line"] == line_no:
+            stack.append((funcs[func_idx], depth))
+            func_idx += 1
+
+        depth += line.count("{") - line.count("}")
+
+        # Pop functions whose scope has closed
+        while stack and depth < stack[-1][1]:
+            stack.pop()
+
+        # Collect calls on this line and attach to innermost function
+        if stack:
+            current = stack[-1][0]
+            for m in _CALL_RE.finditer(line):
+                callee = m.group(1)
+                if callee in _KEYWORD_BLACKLIST or callee == current["name"]:
+                    continue
+                calls = current["calls"]
+                if callee not in calls:
+                    calls.append(callee)
+
+
 def _extract_with_regex(source: str, rel_path: str, ext: str) -> list[dict]:
     lang = _EXT_TO_LANG_NAME.get(ext.lower())
     if not lang or lang not in _REGEX_PATTERNS:
         return []
 
     patterns = _REGEX_PATTERNS[lang]
+    lines = source.splitlines()
     nodes: list[dict] = []
-    seen: set[str]    = set()
+    seen: set[str] = set()
 
-    for line_no, line in enumerate(source.splitlines(), 1):
+    import_names = _collect_imports_regex(source, lang)
+
+    for line_no, line in enumerate(lines, 1):
         for ntype, pattern in patterns.items():
             if not pattern:
                 continue
@@ -401,12 +521,19 @@ def _extract_with_regex(source: str, rel_path: str, ext: str) -> list[dict]:
                 if name and name not in seen:
                     seen.add(name)
                     nodes.append({
-                        "id":   f"{rel_path}::{ntype}::{name}",
-                        "name": name,
-                        "type": ntype,
-                        "file": rel_path,
-                        "line": line_no,
+                        "id":      f"{rel_path}::{ntype}::{name}",
+                        "name":    name,
+                        "type":    ntype,
+                        "file":    rel_path,
+                        "line":    line_no,
+                        "calls":   [],
+                        "imports": import_names[:],
                     })
+
+    func_nodes = [n for n in nodes if n["type"] == "function"]
+    if func_nodes:
+        _attach_calls_brace(lines, func_nodes)
+
     return nodes
 
 

package/codegraph/graph/builder.py

@@ -88,6 +88,16 @@ def build(all_nodes: list[dict]) -> "nx.DiGraph | dict":
                            relation=rel.get("relation", "relates-to"),
                            confidence=rel.get("confidence", "INFERRED"))
 
+    # Resolve unresolved call targets from node['calls'] lists
+    try:
+        from codegraph.graph.symbol_resolution import resolve_calls
+        existing_keys = {(u, v) for u, v in G.edges()}
+        new_edges = resolve_calls(all_nodes, existing_keys)
+        for e in new_edges:
+            G.add_edge(e["from"], e["to"], relation=e["relation"], confidence=e["confidence"])
+    except Exception:
+        pass
+
     return G
 
 

package/codegraph/graph/clustering.py

@@ -1,23 +1,260 @@
 """
-graph/clustering.py — community detection using NetworkX connected-components.
-No external deps beyond networkx (already required).
+graph/clustering.py — community detection using Leiden (graspologic) with Louvain fallback.
+
+Replaces naive connected-components with production-grade algorithm:
+  - Hub exclusion before partitioning
+  - Oversized community splitting (>25% of graph)
+  - Low-cohesion re-splitting
+  - Stable IDs via size-desc lexical sort + previous-run remap
 """
+from __future__ import annotations
 
+import contextlib
+import inspect
+import io
+import json
+import sys
+
+import networkx as nx
+
+
+# ── Low-level partitioner ────────────────────────────────────────────────────
+
+def _suppress_output():
+    return contextlib.redirect_stdout(io.StringIO())
+
+
+def _partition(G: nx.Graph, resolution: float = 1.0) -> dict[str, int]:
+    """Run community detection. Returns {node_id: community_id}.
+
+    Tries Leiden (graspologic) first, falls back to Louvain (networkx).
+    Output is deterministic via sorted nodes/edges and seed=42.
+    """
+    stable = nx.Graph()
+    stable.add_nodes_from(sorted(G.nodes(), key=str))
+    edge_rows = sorted(
+        G.edges(data=True),
+        key=lambda row: (
+            str(row[0]),
+            str(row[1]),
+            json.dumps(row[2], sort_keys=True, ensure_ascii=False, default=str),
+        ),
+    )
+    for src, tgt, attrs in edge_rows:
+        stable.add_edge(src, tgt, **attrs)
 
-def detect_communities(G) -> list[dict]:
-    """Assign community IDs to graph nodes. Returns list of community dicts."""
     try:
-        import networkx as nx
+        from graspologic.partition import leiden
+        lsig = inspect.signature(leiden).parameters
+        kwargs: dict = {}
+        if "random_seed" in lsig:
+            kwargs["random_seed"] = 42
+        if "trials" in lsig:
+            kwargs["trials"] = 1
+        if "resolution" in lsig:
+            kwargs["resolution"] = resolution
+        old_stderr = sys.stderr
+        try:
+            sys.stderr = io.StringIO()
+            with _suppress_output():
+                result = leiden(stable, **kwargs)
+        finally:
+            sys.stderr = old_stderr
+        return result
     except ImportError:
-        return []
+        pass
+
+    kwargs = {"seed": 42, "threshold": 1e-4, "resolution": resolution}
+    if "max_level" in inspect.signature(nx.community.louvain_communities).parameters:
+        kwargs["max_level"] = 10
+    communities = nx.community.louvain_communities(stable, **kwargs)
+    return {node: cid for cid, nodes in enumerate(communities) for node in nodes}
+
+
+# ── Constants ────────────────────────────────────────────────────────────────
+
+_MAX_COMMUNITY_FRACTION = 0.25
+_MIN_SPLIT_SIZE = 10
+_COHESION_SPLIT_THRESHOLD = 0.05
+_COHESION_SPLIT_MIN_SIZE = 50
+
+
+# ── Public API ───────────────────────────────────────────────────────────────
+
+def cluster(
+    G: nx.Graph,
+    resolution: float = 1.0,
+    exclude_hubs_percentile: float | None = None,
+) -> dict[int, list[str]]:
+    """Run Leiden community detection. Returns {community_id: [node_ids]}.
+
+    Community IDs are stable: 0 = largest community.
+    Oversized communities (>25% of nodes, min 10) are split by a second pass.
+    """
+    if G.number_of_nodes() == 0:
+        return {}
+    if G.is_directed():
+        G = G.to_undirected()
+    if G.number_of_edges() == 0:
+        return {i: [n] for i, n in enumerate(sorted(G.nodes))}
+
+    hub_nodes: set[str] = set()
+    if exclude_hubs_percentile is not None:
+        degrees = sorted(d for _, d in G.degree())
+        if degrees:
+            idx = max(0, int(len(degrees) * exclude_hubs_percentile / 100) - 1)
+            threshold = degrees[idx]
+            hub_nodes = {n for n, d in G.degree() if d > threshold}
+
+    excluded = hub_nodes
+    isolates = [n for n in G.nodes() if G.degree(n) == 0 and n not in excluded]
+    connected_nodes = [n for n in G.nodes() if G.degree(n) > 0 and n not in excluded]
+    connected = G.subgraph(connected_nodes)
+
+    raw: dict[int, list[str]] = {}
+    if connected.number_of_nodes() > 0:
+        partition = _partition(connected, resolution=resolution)
+        for node, cid in partition.items():
+            raw.setdefault(cid, []).append(node)
 
+    next_cid = max(raw.keys(), default=-1) + 1
+    for node in isolates:
+        raw[next_cid] = [node]
+        next_cid += 1
+
+    if hub_nodes:
+        node_community: dict[str, int] = {n: cid for cid, nodes in raw.items() for n in nodes}
+        for hub in sorted(hub_nodes):
+            votes: dict[int, int] = {}
+            for nb in G.neighbors(hub):
+                cid = node_community.get(nb)
+                if cid is not None:
+                    votes[cid] = votes.get(cid, 0) + 1
+            if votes:
+                best = min(votes, key=lambda c: (-votes[c], c))
+                raw.setdefault(best, []).append(hub)
+                node_community[hub] = best
+            else:
+                raw[next_cid] = [hub]
+                node_community[hub] = next_cid
+                next_cid += 1
+
+    max_size = max(_MIN_SPLIT_SIZE, int(G.number_of_nodes() * _MAX_COMMUNITY_FRACTION))
+    final_communities: list[list[str]] = []
+    for nodes in raw.values():
+        if len(nodes) > max_size:
+            final_communities.extend(_split_community(G, nodes))
+        else:
+            final_communities.append(nodes)
+
+    second_pass: list[list[str]] = []
+    for nodes in final_communities:
+        if len(nodes) >= _COHESION_SPLIT_MIN_SIZE and cohesion_score(G, nodes) < _COHESION_SPLIT_THRESHOLD:
+            splits = _split_community(G, nodes)
+            second_pass.extend(splits if len(splits) > 1 else [nodes])
+        else:
+            second_pass.append(nodes)
+    final_communities = second_pass
+
+    final_communities.sort(key=lambda nodes: (-len(nodes), tuple(sorted(map(str, nodes)))))
+    return {i: sorted(nodes) for i, nodes in enumerate(final_communities)}
+
+
+def _split_community(G: nx.Graph, nodes: list[str]) -> list[list[str]]:
+    subgraph = G.subgraph(nodes)
+    if subgraph.number_of_edges() == 0:
+        return [[n] for n in sorted(nodes)]
+    try:
+        sub_partition = _partition(subgraph)
+        sub_communities: dict[int, list[str]] = {}
+        for node, cid in sub_partition.items():
+            sub_communities.setdefault(cid, []).append(node)
+        if len(sub_communities) <= 1:
+            return [sorted(nodes)]
+        return [sorted(v) for v in sub_communities.values()]
+    except Exception:
+        return [sorted(nodes)]
+
+
+def cohesion_score(G: nx.Graph, community_nodes: list[str]) -> float:
+    """Ratio of actual intra-community edges to maximum possible."""
+    n = len(community_nodes)
+    if n <= 1:
+        return 1.0
+    subgraph = G.subgraph(community_nodes)
+    actual = subgraph.number_of_edges()
+    possible = n * (n - 1) / 2
+    return actual / possible if possible > 0 else 0.0
+
+
+def remap_communities_to_previous(
+    communities: dict[int, list[str]],
+    previous_node_community: dict[str, int],
+) -> dict[int, list[str]]:
+    """Remap community IDs to maximize overlap with a previous run (stable IDs)."""
+    if not communities:
+        return {}
+    new_sets = {cid: set(nodes) for cid, nodes in communities.items()}
+    old_sets: dict[int, set[str]] = {}
+    for node, old_cid in previous_node_community.items():
+        old_sets.setdefault(old_cid, set()).add(node)
+
+    overlaps: list[tuple[int, int, int]] = []
+    for old_cid, old_nodes in old_sets.items():
+        for new_cid, new_nodes in new_sets.items():
+            overlap = len(old_nodes & new_nodes)
+            if overlap > 0:
+                overlaps.append((overlap, old_cid, new_cid))
+    overlaps.sort(key=lambda x: (-x[0], x[1], x[2]))
+
+    new_to_final: dict[int, int] = {}
+    used_old_ids: set[int] = set()
+    matched_new_ids: set[int] = set()
+    for _overlap, old_cid, new_cid in overlaps:
+        if old_cid in used_old_ids or new_cid in matched_new_ids:
+            continue
+        new_to_final[new_cid] = old_cid
+        used_old_ids.add(old_cid)
+        matched_new_ids.add(new_cid)
+
+    unmatched = [cid for cid in communities if cid not in matched_new_ids]
+    unmatched.sort(key=lambda cid: (-len(communities[cid]), tuple(sorted(communities[cid]))))
+    next_id = 0
+    for new_cid in unmatched:
+        while next_id in used_old_ids:
+            next_id += 1
+        new_to_final[new_cid] = next_id
+        used_old_ids.add(next_id)
+        next_id += 1
+
+    remapped: dict[int, list[str]] = {}
+    for new_cid, nodes in communities.items():
+        remapped[new_to_final[new_cid]] = sorted(nodes)
+    return dict(sorted(remapped.items()))
+
+
+# ── Public wrapper maintaining the existing detect_communities() API ──────────
+
+def detect_communities(G) -> list[dict]:
+    """Assign community IDs to graph nodes. Returns list of community dicts.
+
+    Wraps cluster() so callers don't need to change. Falls back to connected
+    components if networkx community detection is unavailable.
+    """
     if G.number_of_nodes() == 0:
         return []
 
-    undirected = G.to_undirected()
+    try:
+        comm_map = cluster(G)
+    except Exception:
+        # Final fallback: connected components (original behaviour)
+        undirected = G.to_undirected()
+        comm_map = {}
+        for cid, component in enumerate(nx.connected_components(undirected)):
+            comm_map[cid] = sorted(component)
+
     communities = []
-    for comm_id, component in enumerate(nx.connected_components(undirected)):
-        member_ids = list(component)
+    for comm_id, member_ids in comm_map.items():
         label = _community_label(G, member_ids)
         communities.append({"id": comm_id, "label": label, "members": member_ids})
         for nid in member_ids:
@@ -34,7 +271,7 @@ def _community_label(G, member_ids: list) -> str:
         if G.has_node(nid):
             f = G.nodes[nid].get("file", "")
             if f:
-                files.append(f.split("/")[0])
+                files.append(f.replace("\\", "/").split("/")[0])
     if not files:
         return "misc"
     return max(set(files), key=files.count)

package/codegraph/graph/query.py

@@ -41,6 +41,8 @@ def answer(question: str, graph_dict: dict, token_budget: int = 2000) -> dict:
         result = _describe_god_nodes(god_nodes, nodes)
     elif intent == "community" and matched:
         result = _describe_community(matched[0], communities, nodes)
+    elif intent == "circular":
+        result = _circular_imports(graph_dict)
     else:
         result = _general_search(matched, nodes, edges)
 
@@ -124,6 +126,8 @@ def _detect_intent(q: str) -> str:
         return "god_nodes"
     if any(w in q for w in ("community", "cluster", "group", "module")):
         return "community"
+    if any(w in q for w in ("circular", "cycle", "cyclic", "recursive import")):
+        return "circular"
     return "general"
 
 
@@ -225,6 +229,58 @@ def _describe_community(node: dict, communities: list, nodes: list) -> dict:
     }
 
 
+def _circular_imports(graph_dict: dict) -> dict:
+    """Find circular import chains using iterative DFS on import edges."""
+    edges = graph_dict.get("edges", [])
+    nodes = graph_dict.get("nodes", [])
+    node_map = {n["id"]: n for n in nodes}
+
+    adj: dict[str, list[str]] = {}
+    for e in edges:
+        if e.get("relation") in ("imports", "imports_from"):
+            adj.setdefault(e["from"], []).append(e["to"])
+
+    cycles: list[list[str]] = []
+    visited: set[str] = set()
+
+    def dfs(start: str) -> None:
+        stack = [(start, [start], {start})]
+        while stack and len(cycles) < 5:
+            node, path, path_set = stack.pop()
+            for nb in adj.get(node, []):
+                if nb in path_set:
+                    cycle_start = path.index(nb)
+                    cycles.append(path[cycle_start:] + [nb])
+                    if len(cycles) >= 5:
+                        return
+                elif nb not in visited:
+                    visited.add(nb)
+                    stack.append((nb, path + [nb], path_set | {nb}))
+
+    for nid in list(adj.keys()):
+        if nid not in visited:
+            visited.add(nid)
+            dfs(nid)
+        if len(cycles) >= 5:
+            break
+
+    if not cycles:
+        return {"text": "No circular imports detected.", "nodes": [], "confidence": "high"}
+
+    cycle_node_ids: list[str] = []
+    lines = [f"Found {len(cycles)} circular import chain(s):"]
+    for cycle in cycles[:5]:
+        names = [node_map.get(nid, {}).get("name", nid) for nid in cycle]
+        lines.append(f"  {' → '.join(names)}")
+        cycle_node_ids.extend(nid for nid in cycle if nid in node_map)
+
+    return {
+        "text":       "\n".join(lines),
+        "nodes":      [node_map[nid] for nid in dict.fromkeys(cycle_node_ids)][:20],
+        "confidence": "high",
+    }
+
+
 def _general_search(matched: list, nodes: list, edges: list) -> dict:
     if not matched:
         return {"text": "No matching nodes found.", "nodes": [], "confidence": "low"}