codegraphcontext 0.5.4__py3-none-any.whl → 0.5.5__py3-none-any.whl

codegraphcontext/tools/code_finder.py

@@ -654,7 +654,7 @@ class CodeFinder:
                 OPTIONAL MATCH (repo:Repository)-[:CONTAINS]->(file)
                 WITH file, repo, COLLECT({{
                     imported_module: module.name,
-                    import_alias: module.alias,
+                    import_alias: imp.alias,
                     full_import_name: module.full_import_name
                 }}) AS imports
                 RETURN

codegraphcontext/tools/indexing/scip_pipeline.py

@@ -191,12 +191,39 @@ async def run_scip_index_async(
             cgcignore_path=cgcignore_path,
             supported_extensions=set(parsers_keys),
         )
+        minimal_nodes = 0
         for repo_file in supplementary_files:
             abs_str = str(repo_file.resolve())
             if abs_str in scip_abs_paths:
                 continue
             ts_parser = get_parser(repo_file.suffix)
             if not ts_parser:
+                # No parser: still record the file. `discover_files_to_index`
+                # returns supported extensions *plus* generic ones (.md, .json,
+                # .yaml, Dockerfile, .gitignore …), and the Tree-sitter pipeline
+                # gives those a minimal File node (pipeline.py, via
+                # `add_minimal_file_node`) precisely so the graph accounts for
+                # every discovered file.
+                #
+                # Skipping them here left the SCIP path short by exactly the
+                # number of non-code files, so `cgc index` compared a graph
+                # count against the discovery count and reported "only N of M
+                # files indexed. Continuing." on every run, forever.
+                try:
+                    await asyncio.to_thread(
+                        writer.add_minimal_file_node,
+                        repo_file,
+                        index_root,
+                        is_dependency,
+                    )
+                    minimal_nodes += 1
+                    processed += 1
+                    if job_id:
+                        job_manager.update_job(
+                            job_id, processed_files=processed, current_file=abs_str
+                        )
+                except Exception as e:
+                    debug_log(f"Minimal file node failed for {abs_str}: {e}")
                 continue
             try:
                 ts_data = ts_parser.parse(repo_file, is_dependency, index_source=True)
@@ -223,6 +250,10 @@ async def run_scip_index_async(
             info_logger(
                 f"[SCIP+TS] Supplemented {supplemented} files not covered by SCIP indexer"
             )
+        if minimal_nodes:
+            info_logger(
+                f"[SCIP+TS] Recorded {minimal_nodes} non-code file(s) as minimal File nodes"
+            )
 
         info_logger(
             f"[INHERITS] Resolving inheritance links across {len(files_data)} files..."

codegraphcontext/tools/languages/go.py

@@ -34,19 +34,41 @@ GO_QUERIES = {
             )
         ) @interface_node
     """,
+    # `import_spec` is a direct child of `import_declaration` only for a
+    # single-line `import "fmt"`. A grouped block — which gofmt produces for
+    # any file with more than one import, i.e. nearly all of them — nests the
+    # specs inside an `import_spec_list`, so matching only the direct-child
+    # shape returned zero imports for those files.
     "imports": """
         (import_declaration
             (import_spec
                 path: (interpreted_string_literal) @path
             )
         ) @import
-        
+
+        (import_declaration
+            (import_spec_list
+                (import_spec
+                    path: (interpreted_string_literal) @path
+                )
+            )
+        ) @import
+
         (import_declaration
             (import_spec
                 name: (package_identifier) @alias
                 path: (interpreted_string_literal) @path
             )
         ) @import_alias
+
+        (import_declaration
+            (import_spec_list
+                (import_spec
+                    name: (package_identifier) @alias
+                    path: (interpreted_string_literal) @path
+                )
+            )
+        ) @import_alias
     """,
     "calls": """
         (call_expression

codegraphcontext/tools/languages/php.py

@@ -31,8 +31,16 @@ PHP_QUERIES = {
             name: (name) @name
         ) @trait
     """,
+    # A top-level `use App\Models\User;` is a `namespace_use_declaration`.
+    # `use_declaration` is the *trait* use inside a class body (relied on at
+    # ~line 309), so capturing it here dropped every real import and labelled
+    # trait uses as imports instead.
+    #
+    # Capture the clause rather than the declaration: it is the level that
+    # exists once per imported symbol, so the braced group form
+    # `use Foo\{A, B as C};` yields one row per symbol for free.
     "imports": """
-        (use_declaration) @import
+        (namespace_use_clause) @import
     """,
     "calls": """
         (function_call_expression
@@ -394,40 +402,82 @@ class PhpTreeSitterParser:
         for node, capture_name in captures:
             if capture_name == "import":
                 try:
-                    import_text = self._get_node_text(node)
-                    # use Foo\Bar as Baz;
-                    # Node usually has children: name (qualified_name), optional alias
-                    
-                    name_node = None
-                    alias_node = None
-                    
+                    # `namespace_use_clause` shapes, in tree-sitter-php:
+                    #   App\Models\User          -> qualified_name
+                    #   App\Models\Post as Blog  -> qualified_name, name(alias)
+                    #   A                        -> name                 (group member)
+                    #   B as C                   -> name, name(alias)    (group member)
+                    #   function Bar\helper      -> qualified_name, with a
+                    #                               leading `function`/`const` token
+                    #
+                    # The alias, when present, is always the final `name` child.
+                    path_node = None
+                    alias = None
+                    name_children = []
+
                     for child in node.children:
-                        if child.type == "qualified_name" or child.type == "name":
-                            name_node = child
-                        # Alias in PHP: use X as Y; The 'as' is usually implicit structure or explicit?
-                        # Tree sitter grammar: use_declaration -> use_clause -> (use_as_clause (qualified_name) (name))
-                    
-                    # Assuming simple handling for now, extracting string from text
-                    # Regex might be safer given tree complexity for `use`
-                    import_match = re.search(r'use\s+([\w\\]+)(?:\s+as\s+(\w+))?', import_text)
-                    if import_match:
-                        import_path = import_match.group(1).strip()
-                        alias = import_match.group(2).strip() if import_match.group(2) else None
-                        
-                        import_data = {
-                            "name": import_path,
-                            "full_import_name": import_text,
-                            "line_number": node.start_point[0] + 1,
-                            "alias": alias,
-                            "context": (None, None),
-                            "lang": self.language_name,
-                            "is_dependency": False,
-                        }
-                        imports.append(import_data)
+                        if child.type == "qualified_name":
+                            path_node = child
+                        elif child.type == "name":
+                            name_children.append(child)
+
+                    if path_node is not None:
+                        # qualified_name carries the path; a trailing bare name
+                        # is therefore the alias.
+                        import_path = self._get_node_text(path_node)
+                        if name_children:
+                            alias = self._get_node_text(name_children[-1])
+                    elif name_children:
+                        # Group member: first name is the symbol, second (if
+                        # any) is its alias.
+                        import_path = self._get_node_text(name_children[0])
+                        if len(name_children) > 1:
+                            alias = self._get_node_text(name_children[-1])
+                    else:
+                        continue
+
+                    # A braced group prefixes its members: `use Foo\{A, B};`
+                    # means Foo\A and Foo\B. Walk up to recover the prefix so
+                    # the recorded path is the real fully-qualified name.
+                    group = node.parent
+                    if group is not None and group.type == "namespace_use_group":
+                        decl = group.parent
+                        if decl is not None:
+                            # The prefix is a `namespace_name` sibling of the
+                            # group (`use Foo\Bar\{A, B};` -> "Foo\Bar").
+                            prefix_parts = [
+                                self._get_node_text(c)
+                                for c in decl.children
+                                if c.type in ("namespace_name", "qualified_name", "name")
+                            ]
+                            if prefix_parts:
+                                import_path = (
+                                    prefix_parts[0].rstrip("\\") + "\\" + import_path
+                                )
+
+                    import_path = import_path.strip()
+                    if not import_path:
+                        continue
+
+                    import_data = {
+                        # `name` is the symbol as referenced in code — the last
+                        # segment, or the alias when one is given.
+                        "name": alias or import_path.split("\\")[-1],
+                        "full_import_name": import_path,
+                        "line_number": node.start_point[0] + 1,
+                        "alias": alias,
+                        "context": (None, None),
+                        "lang": self.language_name,
+                        "is_dependency": False,
+                    }
+                    imports.append(import_data)
                 except Exception as e:
                     error_logger(f"Error parsing import: {e}")
                     continue
 
+        # Query captures arrive in match order, not source order; sort so the
+        # emitted rows are deterministic across runs.
+        imports.sort(key=lambda i: (i["line_number"], i["full_import_name"]))
         return imports
 
     def _parse_calls(self, captures: list, source_code: str, var_type_map: dict) -> list[dict]:

codegraphcontext/tools/languages/python.py

@@ -303,9 +303,20 @@ class PythonTreeSitterParser:
                                 arg_text = self._get_node_text(name_node)
                         elif p.type == 'typed_parameter':
                             # Typed parameter: def foo(x: int)
-                            name_node = p.child_by_field_name('name')
-                            if name_node:
-                                arg_text = self._get_node_text(name_node)
+                            # `typed_parameter` has no `name` field in
+                            # tree-sitter-python — only `type`. Its children are
+                            # (<identifier|splat>, ':', type), so the parameter
+                            # is the first child. Looking up a `name` field here
+                            # returned None and silently dropped every annotated
+                            # parameter that had no default.
+                            for child in p.children:
+                                if child.type in (
+                                    'identifier',
+                                    'list_splat_pattern',
+                                    'dictionary_splat_pattern',
+                                ):
+                                    arg_text = self._get_node_text(child)
+                                    break
                         elif p.type == 'typed_default_parameter':
                             # Typed parameter with default: def foo(x: int = 5) or def foo(x: str = typer.Argument(...))
                             name_node = p.child_by_field_name('name')

codegraphcontext/tools/query_tool_languages/cpp_toolkit.py

@@ -43,7 +43,7 @@ class CppToolkit:
             return """
                 MATCH (f:File)-[i:IMPORTS]->(m:Module)
                 RETURN f.name AS file_name, m.name AS module_name, 
-                    m.full_import_name AS full_import_name, m.alias AS alias
+                    m.full_import_name AS full_import_name, i.alias AS alias
                 ORDER BY f.name
             """
 

codegraphcontext/utils/gcf_encoder.py

@@ -15,9 +15,12 @@ See https://gcformat.com for the full specification.
 """
 
 import json
+import logging
 import os
 from typing import Any
 
+logger = logging.getLogger(__name__)
+
 _gcf_encode = None
 _gcf_checked = False
 
@@ -53,6 +56,9 @@ def encode_response(result: Any) -> str:
     if is_gcf_enabled():
         encoder = _load_gcf()
         if encoder is not None:
-            return encoder(result)
+            try:
+                return encoder(result)
+            except Exception:
+                logger.debug("GCF encoding failed; falling back to JSON", exc_info=True)
 
     return json.dumps(result, indent=2)

codegraphcontext/utils/path_sandbox.py

@@ -61,11 +61,12 @@ def sanitize_bundle_filename(filename: str, default: str = "bundle.cgc") -> str:
     name = Path(filename).name
     if not name or name in (".", ".."):
         return default
-    if not re.fullmatch(r"[\w.\-]+\.cgc", name, flags=re.IGNORECASE):
-        if not name.endswith(".cgc"):
-            sanitized = re.sub(r'[^\w.\-]+', '_', name)
-            name = f"{sanitized}.cgc"
-    return name
+    # Always sanitize the stem so that unsafe characters cannot bypass the
+    # check by simply appending a .cgc extension.
+    stem = name[:-4] if name.lower().endswith(".cgc") else name
+    sanitized_stem = re.sub(r"[^\w.\-]+", "_", stem)
+    # Re-attach the extension whether it was present or not.
+    return f"{sanitized_stem}.cgc"
 
 
 def is_safe_download_url(url: str) -> bool:

{codegraphcontext-0.5.4.dist-info → codegraphcontext-0.5.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphcontext
-Version: 0.5.4
+Version: 0.5.5
 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.5.4.dist-info → codegraphcontext-0.5.5.dist-info}/RECORD

@@ -39,7 +39,7 @@ codegraphcontext/core/simulator.py,sha256=Sb3PpnoMGVDWvqPVSv5dcQqiL3nTvhmLzzLzJ4
 codegraphcontext/core/watcher.py,sha256=nSfkmZueMBHxx8-7zNHScKtaSGfNWrfjWdAe-T0Y2vI,18793
 codegraphcontext/tools/__init__.py,sha256=iqQPEkDlGXO7rAaLNQrS_ZAbLSklBSK-OowpARq0mig,41
 codegraphcontext/tools/advanced_language_query_tool.py,sha256=QXDKcS3Ug6bNjzY3gjjS2zmPC5cEPyrHGJhAqPXTMuo,4025
-codegraphcontext/tools/code_finder.py,sha256=qUzXrZn2-7pLb2S0FKLI5ZkZtMApT84XaOlF-bSdtZw,72043
+codegraphcontext/tools/code_finder.py,sha256=ZjHoOLYeC5Xc8N4VU5APqGiATzk9AB5gX9u9wVl0SEY,72040
 codegraphcontext/tools/graph_builder.py,sha256=uPHc4q8u7NQ7lSceRm4IwN3nLxgq9C0MvQtkY8HA9CE,57271
 codegraphcontext/tools/package_resolver.py,sha256=d2lkHNguvL_QRihD2bbBN-aMGrXRgsK-8pLWkci3nFk,7366
 codegraphcontext/tools/report_generator.py,sha256=HLCT6sUmYZxouSXsk0vc1ILV-j2jJjer_RXHTV5MskM,15377
@@ -66,7 +66,7 @@ codegraphcontext/tools/indexing/pre_scan.py,sha256=St7Hc3-NFTMYF39vWneJL6iIRIc78
 codegraphcontext/tools/indexing/sanitize.py,sha256=IaTP7Aztso3SsvjNZMEqJ1iktV4Tl75hXcYnCWBGpLs,1490
 codegraphcontext/tools/indexing/schema.py,sha256=AcHaqxDi9d5nGjZdg5S6mbjhHo98UYPRfcz1ZpvNEy4,9157
 codegraphcontext/tools/indexing/schema_contract.py,sha256=23ok37ASjvOsU8S-sqyRiKIkGhcUxQ8PSErbBmylggU,1815
-codegraphcontext/tools/indexing/scip_pipeline.py,sha256=QA5Tje2H7N9C0GHr_ocugDlcYhZAvyx3iVJxUbXLajU,11161
+codegraphcontext/tools/indexing/scip_pipeline.py,sha256=Eb7VKN13vPOJ_Ag34c1yQ4c41TGvsemjMKFHnSjBuCg,12724
 codegraphcontext/tools/indexing/vector_resolver.py,sha256=0D0QClro7nx9Wx6hbbFlOsO4dqgcTrwPMqE0CsJK01o,5477
 codegraphcontext/tools/indexing/persistence/__init__.py,sha256=hFRlNgiYS7uN9X4e4xfP3c1BvcYSxpmq0k_uaDRn2Fg,121
 codegraphcontext/tools/indexing/persistence/utils.py,sha256=OtndHpE_R14mPz5i-Bo9mA7NsoIuYnCNER-oIwxDOYA,2028
@@ -82,7 +82,7 @@ codegraphcontext/tools/languages/css.py,sha256=aN1Nm8vHmfV0J0jQ-_q5x0YDTOtLV2IW-
 codegraphcontext/tools/languages/dart.py,sha256=yjqVA6XwoADrZab95p6wva0jT-PAGw_x90LR-cp2BDk,27160
 codegraphcontext/tools/languages/elisp.py,sha256=QVxJq328bR4DsQK8Vs8b9oxthx1Wm_BS1dsCSjD_P8I,22717
 codegraphcontext/tools/languages/elixir.py,sha256=EvJbTGefz7DUiXvxJQRbwMMcU_TGzaIi6fwd6htKZ9g,21836
-codegraphcontext/tools/languages/go.py,sha256=kU3thNHRhbrakz4YCP94YWp1AvhG_yR73PMLDPdmQME,26129
+codegraphcontext/tools/languages/go.py,sha256=-i3A4lM_Fvp468AfBhCAo1icUmdrI12_z95l-_p_OOA,26938
 codegraphcontext/tools/languages/gradle.py,sha256=WA1nQTi-JMHv5vLTJ35ECW0dQCb4PELt1JxLDKbHijc,4566
 codegraphcontext/tools/languages/haskell.py,sha256=YyslUwcanFs00IinFrj7_TJ2IY2Q97NYsG2Y-9qqolU,19888
 codegraphcontext/tools/languages/html.py,sha256=cjzAH55-JYbObGcMiqjuYD6X0Cbs1Kj5ixcZv9BzMns,5595
@@ -93,8 +93,8 @@ codegraphcontext/tools/languages/lua.py,sha256=TxpOxFd47E4hKwkJpO7b_dMvWveYd4Eaq
 codegraphcontext/tools/languages/maven.py,sha256=yQjrdSRZJPy6tUopZ7x5qYp8Rtbug4PPbBjCdl9FMDY,6393
 codegraphcontext/tools/languages/mybatis.py,sha256=T6mVBCg7_5xOobBIAqZg9oHtZQy7sGFlkPHlK23FoTU,6469
 codegraphcontext/tools/languages/perl.py,sha256=vjz65VFoKLsql2gyaT44B3R0sieloQmxO7fHMp8aqLA,12837
-codegraphcontext/tools/languages/php.py,sha256=s4LPQ7jlRtvVdnDXWwnTD8Mv6V0MsSda4lK43WMn_GM,27163
-codegraphcontext/tools/languages/python.py,sha256=dJ2sQUm_9nOoyUTDlJqV3LigPpN4KhRQLwtBESE6oXY,32016
+codegraphcontext/tools/languages/php.py,sha256=WwdFmWvBxQX8rsqHFCr8tdrz_W3pWv_COp1Bw-xiGiE,29804
+codegraphcontext/tools/languages/python.py,sha256=6Fd05Hxc-jVRTa6t0wYuk8-yZ-0MdrRW3xo1TOucxEk,32714
 codegraphcontext/tools/languages/ruby.py,sha256=GCU2AOfU8H4nNzunf0F4OU_aLr3GGIWcSJgVhO89up8,23428
 codegraphcontext/tools/languages/rust.py,sha256=o_uhEL_a4REPYXqdH4tljucyXMs5ModaMfeT-sanTBc,15560
 codegraphcontext/tools/languages/scala.py,sha256=TmH_DK7baoo7_eMYdu9e7Cqb0ddVpibrhUO5TQD4AsI,23820
@@ -107,7 +107,7 @@ codegraphcontext/tools/languages/typescript.py,sha256=aVGXD-CHxCXs74WOOW1RMSEzz0
 codegraphcontext/tools/languages/typescriptjsx.py,sha256=b-XkR26fhFY8-0UBlayx7FYPAORqik7_LBTVZRvOhLE,7592
 codegraphcontext/tools/languages/vue.py,sha256=XKBoFea_4xMZaDStfkA52wgqc18yQ6COHDBHRduOe-0,1479
 codegraphcontext/tools/query_tool_languages/c_toolkit.py,sha256=kp-CFCOsFZa3sr3qOrH2Bh-ASwI-aaUCbqJSJZMt_Bs,271
-codegraphcontext/tools/query_tool_languages/cpp_toolkit.py,sha256=PW2yVzjYf-0f8GlR15EkXEH7_z_iqfGeUhjQCQH8GAY,3087
+codegraphcontext/tools/query_tool_languages/cpp_toolkit.py,sha256=rVyZq1doOeNvTys24qHQ6YnPDJ8PuJvn72KrPX6rhkk,3087
 codegraphcontext/tools/query_tool_languages/csharp_toolkit.py,sha256=nnfBDN3ejnQytH9mUYKs7IK7RXBsYP4MoqITIZAZADY,281
 codegraphcontext/tools/query_tool_languages/dart_toolkit.py,sha256=W5ClOZ-KCRFmwr7XnEW16YTUfO7LJX67eHTlzXCl23A,277
 codegraphcontext/tools/query_tool_languages/elisp_toolkit.py,sha256=fH8T5HKULMSgq8m46kCUi7Ql1lglTH5taQemJLCrKi0,2591
@@ -126,10 +126,10 @@ codegraphcontext/tools/query_tool_languages/typescript_toolkit.py,sha256=xV7nPSp
 codegraphcontext/utils/cypher_ddl.py,sha256=SuFcCCnHtbyBMoEi6-vWLxt7WdOmRoJC5VAM025iX5I,2767
 codegraphcontext/utils/cypher_readonly.py,sha256=ZlgmFN2_78ME5N8kvgmW82CdvbQTtXVE1vO_I6kPnk0,3119
 codegraphcontext/utils/debug_log.py,sha256=eFKQmaB4iTGzcdytfwZszhcMJCK6jIPxPXKsJOncl4A,3023
-codegraphcontext/utils/gcf_encoder.py,sha256=d56j59t-cqR2tcBx8dQuXA0mFieTMDu8O20oAGCWrZY,1613
+codegraphcontext/utils/gcf_encoder.py,sha256=H6G66BCqbOZpyM_4JOFne5F3YrZRA8fiMnT4S_gRCk8,1806
 codegraphcontext/utils/git_utils.py,sha256=D7ve2gpZaEHk4y6K4ga-o2ka89DVFX1acafD31YAyJM,1383
 codegraphcontext/utils/path_ignore.py,sha256=xaYCSq6nzUVX_mEdn3yrmwM--v7orJImga2XAQeiGB0,2168
-codegraphcontext/utils/path_sandbox.py,sha256=o6bLz3oQcidQwM89KBbmGbKJBtRyz7wgvNLvF7KGqMk,2664
+codegraphcontext/utils/path_sandbox.py,sha256=AemD1DHVMA0lj9BpmRkKwJB2OaE0SewggmJnyi0dr04,2784
 codegraphcontext/utils/repo_path.py,sha256=BxS3y6RV_WaZhg_WxgJygS4SnQa-Ryth2fsicfnYorY,1121
 codegraphcontext/utils/tool_limits.py,sha256=3d-QnlzxBNocz58VKNhdsta7ZpWThs1AX46_gYXl6pQ,2751
 codegraphcontext/utils/tree_sitter_manager.py,sha256=Xr26xYL1HUP8V1Hk9d7tbS4RUb774f-Stc2DtuE7oN0,13307
@@ -173,9 +173,9 @@ codegraphcontext/viz/dist/wasm/tree-sitter-typescript.wasm,sha256=hRVATc7tOOHthq
 codegraphcontext/viz/dist/wasm/tree-sitter.wasm,sha256=CCeVuI_hXktkBD-DW01xYPv5XoAYVRIqzJUJI5te-RY,196763
 codegraphcontext/viz/dist/wasm/web-tree-sitter.js,sha256=DIaCNqRylrT_PBVw8g4ImeSnhP9uXNe_ycOlUiVGPko,153666
 codegraphcontext/viz/dist/wasm/web-tree-sitter.wasm,sha256=CCeVuI_hXktkBD-DW01xYPv5XoAYVRIqzJUJI5te-RY,196763
-codegraphcontext-0.5.4.dist-info/licenses/LICENSE,sha256=rh8M-bJpQYJnw2vtRVgt0t7piMZXh5QzaKeNEI0vqqA,1061
-codegraphcontext-0.5.4.dist-info/METADATA,sha256=hWjnvQZDiclBoydpqEo6fU7Z9G7b2xMWT7Phae4XoZ4,32847
-codegraphcontext-0.5.4.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-codegraphcontext-0.5.4.dist-info/entry_points.txt,sha256=LCxWCWMshdvYGoHBPuQZ8C-e4CiNSHCLXofrNSGHkoE,103
-codegraphcontext-0.5.4.dist-info/top_level.txt,sha256=CBgc6LAPZIO5FS0nSYYkylDifHsZTIqw3Gf5UwDxeGI,17
-codegraphcontext-0.5.4.dist-info/RECORD,,
+codegraphcontext-0.5.5.dist-info/licenses/LICENSE,sha256=rh8M-bJpQYJnw2vtRVgt0t7piMZXh5QzaKeNEI0vqqA,1061
+codegraphcontext-0.5.5.dist-info/METADATA,sha256=g-1RGSS7QULexGiay2b2oPTWrrm8A3XiQYX8QC2D7Eo,32847
+codegraphcontext-0.5.5.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+codegraphcontext-0.5.5.dist-info/entry_points.txt,sha256=LCxWCWMshdvYGoHBPuQZ8C-e4CiNSHCLXofrNSGHkoE,103
+codegraphcontext-0.5.5.dist-info/top_level.txt,sha256=CBgc6LAPZIO5FS0nSYYkylDifHsZTIqw3Gf5UwDxeGI,17
+codegraphcontext-0.5.5.dist-info/RECORD,,