codegraphcontext 0.6.3__tar.gz → 0.6.4__tar.gz

{codegraphcontext-0.6.3/src/codegraphcontext.egg-info → codegraphcontext-0.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphcontext
-Version: 0.6.3
+Version: 0.6.4
 Summary: An MCP server that indexes local code into a graph database to provide context to AI assistants.
 Author-email: Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
 License: MIT License

{codegraphcontext-0.6.3 → codegraphcontext-0.6.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codegraphcontext"
-version = "0.6.3"
+version = "0.6.4"
 description = "An MCP server that indexes local code into a graph database to provide context to AI assistants."
 authors = [{ name = "Shashank Shekhar Singh", email = "shashankshekharsingh1205@gmail.com" }]
 readme = "README.md"

{codegraphcontext-0.6.3 → codegraphcontext-0.6.4}/src/codegraphcontext/cli/main.py

@@ -1178,14 +1178,22 @@ def diagram(
     if level not in ("file", "call"):
         console.print(f"[red]Unknown --level '{level}' (expected file or call)[/red]")
         raise typer.Exit(code=2)
+    # stdout carries only the diagram; init chatter goes to stderr for the
+    # init window only (restored after — a permanent rebind leaks a closed
+    # stream into later in-process invocations).
+    import sys as _sys
+    from . import cli_helpers as _cli_helpers
+    # NB: the .file property GETTER materializes the current (possibly
+    # transient, CliRunner-captured) stream; the dynamic state lives in
+    # ._file, which is None while the console follows sys.stdout live.
+    _prev_console_file = _cli_helpers.console._file
     if output is None:
-        # stdout carries only the diagram; init chatter goes to stderr.
-        import sys as _sys
-        from . import cli_helpers as _cli_helpers
         _cli_helpers.console.file = _sys.stderr
-
-    _load_credentials()
-    services = _initialize_services(context)
+    try:
+        _load_credentials()
+        services = _initialize_services(context)
+    finally:
+        _cli_helpers.console._file = _prev_console_file
     if not all(services[:3]):
         raise typer.Exit(code=1)
     db_manager, graph_builder, code_finder = services[:3]
@@ -3018,15 +3026,24 @@ def analyze_complexity(
     if output_format not in ("text", "json", "csv"):
         console.print(f"[red]Unknown --format '{output_format}' (expected text, json or csv)[/red]")
         raise typer.Exit(code=2)
+    # stdout must carry ONLY the parseable document in machine formats: the
+    # service-init chatter from cli_helpers prints to stdout, so reroute that
+    # console to stderr FOR THE INIT WINDOW ONLY (`--format json | jq .`).
+    # The rebind must be restored — a permanent one leaks a closed stream into
+    # later in-process invocations (CliRunner-based tests).
+    import sys as _sys
+    from . import cli_helpers as _cli_helpers
+    # NB: the .file property GETTER materializes the current (possibly
+    # transient, CliRunner-captured) stream; the dynamic state lives in
+    # ._file, which is None while the console follows sys.stdout live.
+    _prev_console_file = _cli_helpers.console._file
     if output_format in ("json", "csv"):
-        # stdout must carry ONLY the parseable document: the service-init
-        # chatter from cli_helpers prints to stdout, so reroute that console
-        # to stderr before initializing anything (`--format json | jq .`).
-        import sys as _sys
-        from . import cli_helpers as _cli_helpers
         _cli_helpers.console.file = _sys.stderr
-    _load_credentials()
-    services = _initialize_services(context)
+    try:
+        _load_credentials()
+        services = _initialize_services(context)
+    finally:
+        _cli_helpers.console._file = _prev_console_file
     if not all(services[:3]):
         raise typer.Exit(code=1)
     db_manager, graph_builder, code_finder = services[:3]

{codegraphcontext-0.6.3 → codegraphcontext-0.6.4}/src/codegraphcontext/tools/indexing/persistence/writer.py

@@ -1137,6 +1137,8 @@ class GraphWriter:
         )
         batch_size = 500
         backend = get_backend_type(self.driver, self._db_manager)
+        labels = ("Class", "Trait", "Interface", "Struct", "Enum", "Union", "Record", "Mixin", "Extension", "Module", "Object", "Variable")
+
         def _work(session):
             # Dedupe identical rows first: parsers can emit the same
             # (child, parent) record more than once, and while Neo4j's MERGE
@@ -1156,8 +1158,6 @@ class GraphWriter:
             internal_batch = [r for r in deduped_batch if r.get("resolved_parent_file_path") != "__external__"]
             external_batch = [r for r in deduped_batch if r.get("resolved_parent_file_path") == "__external__"]
 
-            labels = ("Class", "Trait", "Interface", "Struct", "Enum", "Union", "Record", "Mixin", "Extension", "Module", "Object", "Variable")
-
             def _label_is_populated(label: str) -> bool:
                 # An empty node table can never match, so skip the pair entirely.
                 # If the existence probe itself fails for any reason, fall back to
@@ -1170,52 +1170,109 @@ class GraphWriter:
                 except Exception:
                     return True
 
+            # Probed once (~12 queries) and reused by the *fallback* enumerations
+            # further down. Deliberately NOT applied to `pair_groups`: those
+            # (child_label, parent_label) pairs are derived from the rows
+            # themselves, so they are never empty -- probing them would be pure
+            # overhead, and a stale or lazily-created label table would make the
+            # probe silently drop real INHERITS edges.
             populated_labels = {label for label in labels if _label_is_populated(label)}
 
-            for child_label in labels:
-                if child_label not in populated_labels:
-                    continue
+            def _chunks(rows):
+                for i in range(0, len(rows), batch_size):
+                    yield rows[i:i + batch_size]
+
+            def _run_internal(rows, child_label, parent_label):
                 child_cypher = _cypher_label(child_label, backend)
-                for parent_label in labels:
-                    if parent_label not in populated_labels:
-                        continue
-                    parent_cypher = _cypher_label(parent_label, backend)
+                parent_cypher = _cypher_label(parent_label, backend)
+                query = f"""
+                    UNWIND $batch AS row
+                    MATCH (child:{child_cypher} {{name: row.child_name, path: row.path}})
+                    MATCH (parent:{parent_cypher} {{name: row.parent_name, path: row.resolved_parent_file_path}})
+                    MERGE (child)-[r:INHERITS]->(parent)
+                    SET r.confidence_label = coalesce(row.confidence_label, 'EXTRACTED')
+                """
+                for chunk in _chunks(rows):
                     try:
-                        session.run(
-                            f"""
-                            UNWIND $batch AS row
-                            MATCH (child:{child_cypher} {{name: row.child_name, path: row.path}})
-                            MATCH (parent:{parent_cypher} {{name: row.parent_name, path: row.resolved_parent_file_path}})
-                            MERGE (child)-[r:INHERITS]->(parent)
-                            SET r.confidence_label = coalesce(row.confidence_label, 'EXTRACTED')
-                        """,
-                            batch=internal_batch,
-                        )
+                        session.run(query, batch=chunk)
                     except Exception as e:
+                        # A label absent in this backend fails to bind for the whole
+                        # (child,parent) group; skip it exactly like the old per-pair loop.
                         if _is_binder_exception(e):
-                            continue
+                            return
                         raise e
 
-            for child_label in labels:
-                if child_label not in populated_labels:
-                    continue
+            def _run_external(rows, child_label):
                 child_cypher = _cypher_label(child_label, backend)
-                try:
-                    session.run(
-                        f"""
-                        UNWIND $batch AS row
-                        MATCH (child:{child_cypher} {{name: row.child_name, path: row.path}})
-                        MERGE (parent:ExternalClass {{name: row.parent_name}})
-                        MERGE (child)-[r:INHERITS]->(parent)
-                        SET r.confidence_label = coalesce(row.confidence_label, 'INFERRED')
-                        """,
-                        batch=external_batch,
-                    )
-                except Exception as e:
-                    if _is_binder_exception(e):
-                        continue
-                    raise e
+                query = f"""
+                    UNWIND $batch AS row
+                    MATCH (child:{child_cypher} {{name: row.child_name, path: row.path}})
+                    MERGE (parent:ExternalClass {{name: row.parent_name}})
+                    MERGE (child)-[r:INHERITS]->(parent)
+                    SET r.confidence_label = coalesce(row.confidence_label, 'INFERRED')
+                """
+                for chunk in _chunks(rows):
+                    try:
+                        session.run(query, batch=chunk)
+                    except Exception as e:
+                        if _is_binder_exception(e):
+                            return
+                        raise e
 
+            # Group internal rows by the labels resolution pinned down, so only the
+            # (child_label, parent_label) pairs that actually occur run — instead of a
+            # 12x12 brute force that re-scans the full batch for every combination.
+            #   both labels known   -> one exact query per (child, parent) pair
+            #   child known only    -> enumerate parent labels over just those rows
+            #   neither             -> full 12x12 (rare: ambiguous (name,path) label collision)
+            # Rows never gain a label they wouldn't have matched, and unknown/ambiguous
+            # cases fall back to enumeration, so the produced edge set is unchanged.
+            pair_groups: Dict[tuple, List[Dict[str, Any]]] = {}
+            child_only_groups: Dict[str, List[Dict[str, Any]]] = {}
+            legacy_rows: List[Dict[str, Any]] = []
+            for row in internal_batch:
+                cl = row.get("child_label")
+                pl = row.get("parent_label")
+                if cl and pl:
+                    pair_groups.setdefault((cl, pl), []).append(row)
+                elif cl:
+                    child_only_groups.setdefault(cl, []).append(row)
+                else:
+                    legacy_rows.append(row)
+
+            for (cl, pl), rows in pair_groups.items():
+                _run_internal(rows, cl, pl)
+            for cl, rows in child_only_groups.items():
+                for pl in labels:
+                    if pl not in populated_labels:
+                        continue
+                    _run_internal(rows, cl, pl)
+            if legacy_rows:
+                for cl in labels:
+                    if cl not in populated_labels:
+                        continue
+                    for pl in labels:
+                        if pl not in populated_labels:
+                            continue
+                        _run_internal(legacy_rows, cl, pl)
+
+            # External parents (ExternalClass): group by known child label; fall back to
+            # enumerating child labels for any label-less rows.
+            ext_by_child: Dict[str, List[Dict[str, Any]]] = {}
+            ext_legacy: List[Dict[str, Any]] = []
+            for row in external_batch:
+                cl = row.get("child_label")
+                if cl:
+                    ext_by_child.setdefault(cl, []).append(row)
+                else:
+                    ext_legacy.append(row)
+            for cl, rows in ext_by_child.items():
+                _run_external(rows, cl)
+            if ext_legacy:
+                for cl in labels:
+                    if cl not in populated_labels:
+                        continue
+                    _run_external(ext_legacy, cl)
 
             for file_data in csharp_files:
                 self._create_csharp_inheritance_and_interfaces(session, file_data, imports_map)

{codegraphcontext-0.6.3 → codegraphcontext-0.6.4}/src/codegraphcontext/tools/indexing/resolution/inheritance.py

@@ -6,6 +6,58 @@ from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple
 
 
+
+# Child construct list -> node label: the 8 kinds that can declare inheritance.
+_INHERIT_KEY_TO_LABEL = {
+    "classes": "Class",
+    "structs": "Struct",
+    "traits": "Trait",
+    "interfaces": "Interface",
+    "mixins": "Mixin",
+    "enums": "Enum",
+    "extensions": "Extension",
+    "variables": "Variable",
+}
+
+# All construct lists whose nodes can be an INHERITS parent, mapped to their label.
+# Matches the 12 labels the writer enumerates. Used to attach exact child/parent
+# labels to rows and to detect the rare (name, path) collisions where more than one
+# node kind shares a name+path — those stay ambiguous so the writer falls back to
+# full enumeration (keeping the produced edge set identical).
+_NODE_KEY_TO_LABEL = {
+    "classes": "Class",
+    "traits": "Trait",
+    "interfaces": "Interface",
+    "structs": "Struct",
+    "enums": "Enum",
+    "unions": "Union",
+    "records": "Record",
+    "mixins": "Mixin",
+    "extensions": "Extension",
+    "modules": "Module",
+    "objects": "Object",
+    "variables": "Variable",
+}
+
+
+def _build_node_label_index(
+    all_file_data: List[Dict[str, Any]],
+) -> Dict[str, Dict[str, set]]:
+    """Map normalized path -> {name -> set(labels)} across all inheritance-eligible
+    node kinds. A (path, name) with exactly one label lets the writer target that
+    label directly; multiple labels leaves it ambiguous (writer enumerates)."""
+    index: Dict[str, Dict[str, set]] = {}
+    for file_data in all_file_data:
+        fpath = str(Path(file_data["path"]).resolve().as_posix())
+        per_file = index.setdefault(fpath, {})
+        for key, label in _NODE_KEY_TO_LABEL.items():
+            for item in file_data.get(key, []):
+                name = item.get("name")
+                if name:
+                    per_file.setdefault(name, set()).add(label)
+    return index
+
+
 def resolve_inheritance_link(
     class_item: Dict[str, Any],
     base_class_str: str,
@@ -13,6 +65,8 @@ def resolve_inheritance_link(
     local_class_names: set,
     local_imports: dict,
     imports_map: dict,
+    child_label: Optional[str] = None,
+    node_label_index: Optional[Dict[str, Dict[str, set]]] = None,
 ) -> Optional[Dict[str, Any]]:
     """Resolve a single inheritance link. Returns row dict or None."""
     import re
@@ -55,21 +109,41 @@ def resolve_inheritance_link(
             if len(possible_paths) == 1:
                 resolved_path = possible_paths[0]
 
+    # Pin the child label only when this (path, name) is a single node kind. If more
+    # than one kind shares it, leave it off so the writer enumerates (byte-identical).
+    child_lbl = None
+    if child_label:
+        if node_label_index is None:
+            child_lbl = child_label
+        else:
+            present = node_label_index.get(caller_file_path, {}).get(class_item["name"])
+            if present and len(present) == 1 and child_label in present:
+                child_lbl = child_label
+
+    def _with_labels(row: Dict[str, Any], parent_path: str) -> Dict[str, Any]:
+        if child_lbl:
+            row["child_label"] = child_lbl
+        if node_label_index is not None:
+            plabels = node_label_index.get(parent_path, {}).get(target_class_name)
+            if plabels and len(plabels) == 1:
+                row["parent_label"] = next(iter(plabels))
+        return row
+
     if resolved_path:
-        return {
+        return _with_labels({
             "child_name": class_item["name"],
             "path": caller_file_path,
             "parent_name": target_class_name,
             "resolved_parent_file_path": resolved_path,
             "confidence_label": "EXTRACTED",
-        }
-    return {
+        }, resolved_path)
+    return _with_labels({
         "child_name": class_item["name"],
         "path": caller_file_path,
         "parent_name": target_class_name,
         "resolved_parent_file_path": "__external__",
         "confidence_label": "INFERRED",
-    }
+    }, "__external__")
 
 
 
@@ -79,6 +153,7 @@ def build_inheritance_and_csharp_files(
     """Returns (inheritance_batch_rows, csharp_file_data_list)."""
     inheritance_batch: List[Dict[str, Any]] = []
     csharp_files: List[Dict[str, Any]] = []
+    node_label_index = _build_node_label_index(all_file_data)
 
     for file_data in all_file_data:
         if file_data.get("lang") == "c_sharp":
@@ -87,7 +162,7 @@ def build_inheritance_and_csharp_files(
 
         caller_file_path = str(Path(file_data["path"]).resolve().as_posix())
         local_class_names = set()
-        for key in ["classes", "structs", "traits", "interfaces", "mixins", "enums", "extensions", "variables"]:
+        for key in _INHERIT_KEY_TO_LABEL:
             for item in file_data.get(key, []):
                 local_class_names.add(item["name"])
 
@@ -97,7 +172,7 @@ def build_inheritance_and_csharp_files(
             if imp.get("name")
         }
 
-        for key in ["classes", "structs", "traits", "interfaces", "mixins", "enums", "extensions", "variables"]:
+        for key, child_label in _INHERIT_KEY_TO_LABEL.items():
             for class_item in file_data.get(key, []):
                 if not class_item.get("bases"):
                     continue
@@ -109,6 +184,8 @@ def build_inheritance_and_csharp_files(
                         local_class_names,
                         local_imports,
                         imports_map,
+                        child_label=child_label,
+                        node_label_index=node_label_index,
                     )
                     if resolved:
                         inheritance_batch.append(resolved)

{codegraphcontext-0.6.3 → codegraphcontext-0.6.4}/src/codegraphcontext/tools/languages/csharp.py

@@ -308,7 +308,26 @@ class CSharpTreeSitterParser:
                             # Parse base list: ": BaseClass, IInterface1, IInterface2"
                             bases_text = bases_text.strip().lstrip(':').strip()
                             if bases_text:
-                                raw_bases = [b.strip() for b in bases_text.split(',')]
+                                # Split on TOP-LEVEL commas only: a naive split
+                                # shredded multi-arg generics —
+                                # `: Dictionary<string, int>` became two bases,
+                                # 'Dictionary<string' and 'int>', creating
+                                # INHERITS edges to nonexistent types (#1538).
+                                raw_bases = []
+                                depth = 0
+                                current = []
+                                for ch in bases_text:
+                                    if ch in "<([":
+                                        depth += 1
+                                    elif ch in ">)]":
+                                        depth = max(0, depth - 1)
+                                    if ch == "," and depth == 0:
+                                        raw_bases.append("".join(current).strip())
+                                        current = []
+                                    else:
+                                        current.append(ch)
+                                if current:
+                                    raw_bases.append("".join(current).strip())
                                 # records might have base calls like : Person(name, age)
                                 # we want just Person
                                 for rb in raw_bases:

{codegraphcontext-0.6.3 → codegraphcontext-0.6.4}/src/codegraphcontext/tools/languages/dart.py

@@ -490,15 +490,22 @@ class DartTreeSitterParser:
                 if uri_node:
                     uri_text = self._get_node_text(uri_node).strip("'\"")
                     
-                    # Handle 'as' alias
+                    # Handle 'as' alias. This grammar has no 'prefix' node
+                    # (and no 'identifier' field on one): the alias is the bare
+                    # identifier child following the 'as' keyword inside
+                    # import_specification — the old lookup always came back
+                    # empty, so `math.max(...)` could never be mapped to its
+                    # import (#1538).
                     alias = None
                     for child in node.children:
                         if child.type == 'import_specification':
+                            saw_as = False
                             for sub in child.children:
-                                if sub.type == 'prefix':
-                                    alias_node = sub.child_by_field_name('identifier')
-                                    if alias_node:
-                                        alias = self._get_node_text(alias_node)
+                                if sub.type == 'as':
+                                    saw_as = True
+                                elif saw_as and sub.type == 'identifier':
+                                    alias = self._get_node_text(sub)
+                                    break
                     
                     imports.append({
                         "name": uri_text,

{codegraphcontext-0.6.3 → codegraphcontext-0.6.4}/src/codegraphcontext/tools/languages/python.py

@@ -455,7 +455,15 @@ class PythonTreeSitterParser:
                             imported_name = self._get_node_text(child)
                         
                         if imported_name:
-                            full_import_name = f"{module_name}.{imported_name}"
+                            # `from . import x` has module_name '.', and the
+                            # unconditional join produced '..x' — one package
+                            # level too high, and no consumer strips leading
+                            # dots (#1538). Bare-dot relatives join without
+                            # the separator; dotted paths keep it.
+                            if module_name.endswith('.'):
+                                full_import_name = f"{module_name}{imported_name}"
+                            else:
+                                full_import_name = f"{module_name}.{imported_name}"
                             import_data = {
                                 "name": imported_name,
                                 "source": module_name,

{codegraphcontext-0.6.3 → codegraphcontext-0.6.4}/src/codegraphcontext/tools/languages/ruby.py

@@ -6,9 +6,14 @@ from codegraphcontext.utils.tree_sitter_manager import execute_query
 
 RUBY_QUERIES = {
     "functions": """
-        (method
-            name: (identifier) @name
-        ) @function_node
+        [
+            (method
+                name: (identifier) @name
+            )
+            (singleton_method
+                name: (identifier) @name
+            )
+        ] @function_node
     """,
     "classes": """
         (class
@@ -584,6 +589,9 @@ def pre_scan_ruby(files: list[Path], parser_wrapper) -> dict:
         (method
             name: (identifier) @name
         )
+        (singleton_method
+            name: (identifier) @name
+        )
     """
     
 

{codegraphcontext-0.6.3 → codegraphcontext-0.6.4}/src/codegraphcontext/tools/languages/rust.py

@@ -289,33 +289,67 @@ class RustTreeSitterParser:
         return structs, enums, traits
 
     def _find_imports(self, root_node: Any) -> list[Dict[str, Any]]:
+        """Walk `use` declarations structurally (#1538).
+
+        The old text-based version had two audit findings: a braced list
+        (`use std::collections::{HashMap, HashSet};`) kept only the LAST
+        name, and `full_import_name` was the raw source including the `use`
+        keyword and semicolon — written verbatim as the Module node name,
+        where no path-matching consumer could ever match it.
+        """
         imports = []
+
+        def _emit(name, full, alias, line):
+            imports.append({
+                "name": name,
+                "full_import_name": full,
+                "line_number": line,
+                "alias": alias,
+            })
+
+        def _last_segment(path_text):
+            seg = path_text.split("::")[-1].strip()
+            return seg or path_text
+
+        def _walk_use_arg(node, base, line):
+            """base is the '::'-joined path prefix accumulated so far."""
+            t = node.type
+            text = self._get_node_text(node)
+            if t in ("identifier", "scoped_identifier", "crate", "self", "super"):
+                full = f"{base}::{text}" if base else text
+                _emit(_last_segment(full), full, None, line)
+            elif t == "use_as_clause":
+                inner = node.children[0]
+                alias_node = node.children[-1]
+                inner_text = self._get_node_text(inner)
+                full = f"{base}::{inner_text}" if base else inner_text
+                _emit(self._get_node_text(alias_node), full, self._get_node_text(alias_node), line)
+            elif t == "use_wildcard":
+                # use x::*;  — child[0] is the path, if any (super/crate/self
+                # are their own node types, not identifiers)
+                path_children = [c for c in node.children if c.type in ("identifier", "scoped_identifier", "super", "crate", "self")]
+                prefix = self._get_node_text(path_children[0]) if path_children else ""
+                full_base = f"{base}::{prefix}" if base and prefix else (prefix or base)
+                _emit("*", f"{full_base}::*" if full_base else "*", None, line)
+            elif t == "scoped_use_list":
+                # <path> :: { list }
+                path_children = [c for c in node.children if c.type in ("identifier", "scoped_identifier", "super", "crate", "self")]
+                prefix = self._get_node_text(path_children[0]) if path_children else ""
+                new_base = f"{base}::{prefix}" if base and prefix else (prefix or base)
+                for c in node.children:
+                    if c.type == "use_list":
+                        _walk_use_arg(c, new_base, line)
+            elif t == "use_list":
+                for c in node.children:
+                    if c.type not in ("{", "}", ","):
+                        _walk_use_arg(c, base, line)
+
         query_str = RUST_QUERIES["imports"]
         for node, _ in execute_query(self.language, query_str, root_node):
-            full_import_name = self._get_node_text(node)
-            alias = None
-
-            alias_match = re.search(r"as\s+(\w+)\s*;?$", full_import_name)
-            if alias_match:
-                alias = alias_match.group(1)
-                name = alias
-            else:
-                cleaned_path = re.sub(r";$", "", full_import_name).strip()
-                last_part = cleaned_path.split("::")[-1]
-                if last_part.strip() == "*":
-                    name = "*"
-                else:
-                    name_match = re.findall(r"(\w+)", last_part)
-                    name = name_match[-1] if name_match else last_part
-
-            imports.append(
-                {
-                    "name": name,
-                    "full_import_name": full_import_name,
-                    "line_number": node.start_point[0] + 1,
-                    "alias": alias,
-                }
-            )
+            line = node.start_point[0] + 1
+            for child in node.children:
+                if child.type not in ("use", ";"):
+                    _walk_use_arg(child, "", line)
         return imports
 
     def _find_calls(self, root_node: Any) -> list[Dict[str, Any]]:

{codegraphcontext-0.6.3 → codegraphcontext-0.6.4}/src/codegraphcontext/tools/languages/scala.py

@@ -9,7 +9,7 @@ SCALA_QUERIES = {
     "functions": """
         (function_definition
             name: (identifier) @name
-            parameters: (parameters) @params
+            parameters: (parameters)? @params
         ) @function_node
     """,
     "classes": """

{codegraphcontext-0.6.3 → codegraphcontext-0.6.4/src/codegraphcontext.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphcontext
-Version: 0.6.3
+Version: 0.6.4
 Summary: An MCP server that indexes local code into a graph database to provide context to AI assistants.
 Author-email: Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
 License: MIT License