codegraphcontext 0.5.4__tar.gz → 0.5.6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphcontext
-Version: 0.5.4
+Version: 0.5.6
 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.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codegraphcontext"
-version = "0.5.4"
+version = "0.5.6"
 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.6}/src/codegraphcontext/tools/advanced_language_query_tool.py

@@ -82,10 +82,12 @@ class Advanced_language_query:
 
         if language not in self.TOOLKITS:
             raise ValueError(f"Unsupported language: {language}")
-        self.toolkit = self.TOOLKITS[language]()
-
-        # Getting the language query
-        cypher_query = self.toolkit.get_cypher_query(label)
+        try:
+            self.toolkit = self.TOOLKITS[language]()
+            # Getting the language query
+            cypher_query = self.toolkit.get_cypher_query(label)
+        except NotImplementedError as exc:
+            return {"error": str(exc), "language": language, "query": query}
         try:
             debug_log(f"Executing Cypher query: {cypher_query}")
             with self.db_manager.get_driver().session() as session:

{codegraphcontext-0.5.4 → codegraphcontext-0.5.6}/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.6}/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.6}/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.6}/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.6}/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.6}/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.6}/src/codegraphcontext/tools/query_tool_languages/java_toolkit.py

@@ -12,15 +12,23 @@ from typing import Any, Dict, List, Optional
 
 
 class JavaToolkit:
-    """Spring-aware Java analysis methods backed by CodeFinder / raw Cypher."""
+    """Spring-aware Java analysis methods backed by CodeFinder / raw Cypher.
 
-    def __init__(self, code_finder: Any):
-        """
-        Args:
-            code_finder: A ``CodeFinder`` instance (or compatible duck-type).
-        """
+    Note: The generic ``advanced_language_query`` path calls this toolkit
+    with no arguments (consistent with all other language toolkits). The
+    Spring-specific MCP tools (``find_java_spring_endpoints`` /
+    ``find_java_spring_beans``) pass a ``code_finder`` via ``_init_with``.
+    """
+
+    def __init__(self) -> None:
+        self._cf: Any = None
+        self._driver: Any = None
+
+    def _init_with(self, code_finder: Any) -> "JavaToolkit":
+        """Initialise with a live CodeFinder for Spring-specific queries."""
         self._cf = code_finder
         self._driver = code_finder.driver
+        return self
 
     # ── Internal helpers ──────────────────────────────────────────────────────
 
@@ -249,5 +257,6 @@ class JavaToolkit:
     # Legacy shim — keeps existing callers working
     def get_cypher_query(self, query: str) -> str:
         raise NotImplementedError(
+            "AdvancedLanguageQuery is not implemented yet for Java. "
             "Use find_spring_endpoints(), find_beans_by_stereotype(), etc. instead."
         )

{codegraphcontext-0.5.4 → codegraphcontext-0.5.6}/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.6}/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.6}/src/codegraphcontext/utils/visualize_graph.py

@@ -12,6 +12,7 @@ import json
 import os
 import tempfile
 import webbrowser
+from html import escape as html_escape
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
@@ -55,6 +56,24 @@ def edge_color(rel_type: str) -> str:
     return _EDGE_COLORS.get(rel_type, _EDGE_COLORS["default"])
 
 
+def _json_for_script(data: Any) -> str:
+    """Serialise ``data`` for inlining inside a ``<script>`` element.
+
+    ``json.dumps`` escapes quotes and backslashes but leaves ``<``, ``>`` and
+    ``&`` alone, so a node name or file path containing ``</script>`` closes
+    the element early and the rest of the document is parsed as markup. Those
+    three characters only ever appear inside string literals, so replacing
+    them with their ``\\uXXXX`` form keeps the payload valid JSON and valid
+    JavaScript while making it inert as markup.
+    """
+    return (
+        json.dumps(data, indent=2)
+        .replace("<", "\\u003c")
+        .replace(">", "\\u003e")
+        .replace("&", "\\u0026")
+    )
+
+
 def build_graph_data(
     nodes: List[Dict[str, Any]],
     edges: List[Dict[str, Any]],
@@ -125,14 +144,15 @@ def render_html(
     str
         Complete HTML document as a string.
     """
-    graph_json = json.dumps(graph_data, indent=2)
+    graph_json = _json_for_script(graph_data)
+    safe_title = html_escape(title)
 
     html = f"""<!DOCTYPE html>
 <html lang="en">
 <head>
   <meta charset="UTF-8" />
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-  <title>{title}</title>
+  <title>{safe_title}</title>
   <style>
     * {{ box-sizing: border-box; margin: 0; padding: 0; }}
     body {{
@@ -198,7 +218,7 @@ def render_html(
 </head>
 <body>
   <div id="header">
-    <h1>🏗 {title}</h1>
+    <h1>🏗 {safe_title}</h1>
     <span id="stats"></span>
   </div>
   <div id="canvas-container">

{codegraphcontext-0.5.4 → codegraphcontext-0.5.6}/src/codegraphcontext/viz/server.py

@@ -96,13 +96,16 @@ def _get_eid(element):
     if isinstance(element, (int, str)):
         return str(element)
     
-    # If element is a dict (like Neo4j returned items or KuzuDB node/rel dicts)
+    # If element is a dict (like Neo4j returned items or KuzuDB/Ladybug node/rel
+    # dicts). KùzuDB spells its internal id field '_id'; LadybugDB spells the
+    # same field '_ID' (uppercase) — confirmed against a live query on each
+    # embedded backend.
     if isinstance(element, dict):
         # KuzuDB _src / _dst are directly {'offset': X, 'table': Y}
         if 'offset' in element and 'table' in element:
             return f"{element.get('table')}_{element.get('offset')}"
-            
-        for key in ['_id', 'id', 'element_id']:
+
+        for key in ['_id', '_ID', 'id', 'element_id']:
             if key in element:
                 val = element[key]
                 if val is not None:
@@ -116,7 +119,7 @@ def _get_eid(element):
     for attr in ['element_id', 'id', '_id']:
         if hasattr(element, attr):
             val = getattr(element, attr)
-            if val is not None: 
+            if val is not None:
                 # KuzuDB objects if any
                 if isinstance(val, dict):
                     return f"{val.get('table', 0)}_{val.get('offset', 0)}"
@@ -124,6 +127,18 @@ def _get_eid(element):
     return str(id(element))
 
 
+def _meta(d: dict, name: str):
+    """Read a KùzuDB/LadybugDB internal dict field regardless of its casing.
+
+    KùzuDB spells these fields lowercase (_label/_src/_dst); LadybugDB spells
+    the same fields uppercase (_LABEL/_SRC/_DST) — confirmed against a live
+    query on each embedded backend. Keying on one casing only silently drops
+    every row on the other backend.
+    """
+    lower = f"_{name}"
+    return d[lower] if lower in d else d.get(f"_{name.upper()}")
+
+
 @app.get("/api/graph")
 async def get_graph(repo_path: Optional[str] = None, cypher_query: Optional[str] = None):
     if not db_manager:
@@ -186,9 +201,10 @@ async def get_graph(repo_path: Optional[str] = None, cypher_query: Optional[str]
                                 # Extract labels
                                 labels = []
                                 if isinstance(node, dict):
-                                    # KuzuDB node label is under '_label'
-                                    if '_label' in node:
-                                        labels = [node['_label']]
+                                    # KuzuDB node label is under '_label' (LadybugDB: '_LABEL')
+                                    meta_label = _meta(node, 'label')
+                                    if meta_label is not None:
+                                        labels = [meta_label]
                                     elif 'label' in node:
                                         labels = [node['label']]
                                 else:
@@ -247,13 +263,17 @@ async def get_graph(repo_path: Optional[str] = None, cypher_query: Optional[str]
                         # FalkorDB / KuzuDB may return rels as dicts OR objects
                         if isinstance(rel, dict):
                             rid = get_eid(rel)
-                            # KuzuDB uses _src and _dst, FalkorDB uses src_node/dest_node
-                            src = rel.get('_src', rel.get('src_node'))
-                            dst = rel.get('_dst', rel.get('dest_node'))
-                            
+                            # KuzuDB uses _src/_dst (LadybugDB: _SRC/_DST), FalkorDB uses src_node/dest_node
+                            src = _meta(rel, 'src')
+                            if src is None:
+                                src = rel.get('src_node')
+                            dst = _meta(rel, 'dst')
+                            if dst is None:
+                                dst = rel.get('dest_node')
+
                             source = get_eid(src) if src is not None else None
                             target = get_eid(dst) if dst is not None else None
-                            rel_type = str(rel.get('_label', rel.get('relation', rel.get('type', 'RELATED')))).upper()
+                            rel_type = str(_meta(rel, 'label') or rel.get('relation', rel.get('type', 'RELATED'))).upper()
                         else:
                             rid = get_eid(rel)
                             start_node = None
@@ -420,8 +440,9 @@ def parse_node(node, nodes_dict):
         
     labels = []
     if isinstance(node, dict):
-        if '_label' in node:
-            labels = [node['_label']]
+        meta_label = _meta(node, 'label')
+        if meta_label is not None:
+            labels = [meta_label]
         elif 'label' in node:
             labels = [node['label']]
     else:
@@ -463,11 +484,15 @@ def parse_node(node, nodes_dict):
 def parse_rel(rel, edges):
     rid = _get_eid(rel)
     if isinstance(rel, dict):
-        src = rel.get('_src', rel.get('src_node'))
-        dst = rel.get('_dst', rel.get('dest_node'))
+        src = _meta(rel, 'src')
+        if src is None:
+            src = rel.get('src_node')
+        dst = _meta(rel, 'dst')
+        if dst is None:
+            dst = rel.get('dest_node')
         source = _get_eid(src) if src is not None else None
         target = _get_eid(dst) if dst is not None else None
-        rel_type = str(rel.get('_label', rel.get('relation', rel.get('type', 'RELATED')))).upper()
+        rel_type = str(_meta(rel, 'label') or rel.get('relation', rel.get('type', 'RELATED'))).upper()
     else:
         start_node = None
         end_node = None
@@ -510,9 +535,16 @@ def parse_element(val, nodes_dict, edges):
         
     type_name = type(val).__name__
     
-    if type_name in ('Node', 'KuzuNode') or (isinstance(val, dict) and ('_label' in val or 'labels' in val) and not any(k in val for k in ('_src', '_dst', 'src_node', 'dest_node'))):
+    is_dict_rel = isinstance(val, dict) and (
+        any(k in val for k in ('_src', '_dst', '_SRC', '_DST', 'src_node', 'dest_node'))
+    )
+    is_dict_node = isinstance(val, dict) and (
+        '_label' in val or '_LABEL' in val or 'labels' in val
+    ) and not is_dict_rel
+
+    if type_name in ('Node', 'KuzuNode') or is_dict_node:
         parse_node(val, nodes_dict)
-    elif type_name in ('Relationship', 'KuzuRelationship') or (isinstance(val, dict) and any(k in val for k in ('_src', '_dst', 'src_node', 'dest_node'))):
+    elif type_name in ('Relationship', 'KuzuRelationship') or is_dict_rel:
         parse_rel(val, edges)
     elif isinstance(val, (list, tuple)):
         for item in val:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphcontext
-Version: 0.5.4
+Version: 0.5.6
 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