codegraphcontext 0.5.4__tar.gz → 0.5.5__tar.gz

{codegraphcontext-0.5.4/src/codegraphcontext.egg-info → codegraphcontext-0.5.5}/PKG-INFO

@@ -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 → codegraphcontext-0.5.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codegraphcontext"
-version = "0.5.4"
+version = "0.5.5"
 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.5.4 → codegraphcontext-0.5.5}/src/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-0.5.4 → codegraphcontext-0.5.5}/src/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-0.5.4 → codegraphcontext-0.5.5}/src/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-0.5.4 → codegraphcontext-0.5.5}/src/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-0.5.4 → codegraphcontext-0.5.5}/src/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-0.5.4 → codegraphcontext-0.5.5}/src/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-0.5.4 → codegraphcontext-0.5.5}/src/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-0.5.4 → codegraphcontext-0.5.5}/src/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 → codegraphcontext-0.5.5/src/codegraphcontext.egg-info}/PKG-INFO

@@ -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