codegraphcontext 0.6.8__py3-none-any.whl → 0.6.9__py3-none-any.whl

codegraphcontext/cli/cli_helpers.py

@@ -26,6 +26,7 @@ from ..core import get_database_manager
 from ..core.jobs import JobManager
 from ..tools.code_finder import CodeFinder
 from ..tools.graph_builder import GraphBuilder
+from ..utils import graph_shapes
 from ..tools.package_resolver import get_local_package_path
 from ..utils.debug_log import info_logger, warning_logger
 from ..core.database import Neo4jConnectionError
@@ -227,7 +228,14 @@ def _initialize_services(
                     _fail_services_init()
             else:
                 console.print(f"[bold red]Database Connection Error:[/bold red] {e}")
-                console.print("Please ensure your database is configured correctly or run 'cgc doctor'.")
+                if "Could not set lock on file" in str(e):
+                    console.print(
+                        "[yellow]Another CGC process already has this embedded database open. "
+                        "If a CGC Gateway or watcher is running, use its MCP/HTTP interface "
+                        "or stop it before running database-backed CLI commands.[/yellow]"
+                    )
+                else:
+                    console.print("Please ensure your database is configured correctly or run 'cgc doctor'.")
                 _fail_services_init()
     
     # The GraphBuilder requires an event loop, even for synchronous-style execution
@@ -657,44 +665,13 @@ def _render_offline_visualization(
     def _ident(value) -> Optional[str]:
         return None if value is None else str(value)
 
-    # Kùzu spells the internal record keys in lowercase (_label/_src/_dst/_id);
-    # Ladybug returns the same fields uppercased (_LABEL/_SRC/_DST/_ID). Look
-    # up both spellings so either backend reaches the offline renderer (#1458).
-    def _meta(d: dict, key: str, default=None):
-        if key in d:
-            return d[key]
-        return d.get(key.upper(), default)
-
-    def _has_meta(d: dict, key: str) -> bool:
-        return key in d or key.upper() in d
-
-    # Neo4j returns driver objects carrying .labels / .type that support
-    # dict()/Mapping access. FalkorDB's own driver objects also carry
-    # .labels on nodes, but are NOT dict-convertible — their properties live
-    # in a plain `.properties` dict, and its Edge exposes `.relation` /
-    # `.src_node` / `.dest_node` instead of `.type` / `.start_node` /
-    # `.end_node`. Kùzu and Ladybug return plain dicts carrying _label plus
-    # _src/_dst. Check the driver attributes first — a driver object may
-    # also be dict-like.
-    def _is_relationship(value) -> bool:
-        if hasattr(value, "labels"):
-            return False
-        if hasattr(value, "type"):
-            return True
-        if hasattr(value, "relation") and hasattr(value, "src_node"):
-            return True
-        return isinstance(value, dict) and _has_meta(value, "_src") and _has_meta(value, "_dst")
-
-    def _is_node(value) -> bool:
-        if hasattr(value, "labels"):
-            return True
-        if hasattr(value, "type"):
-            return False
-        if hasattr(value, "relation") and hasattr(value, "src_node"):
-            return False
-        # Kùzu relationships also carry _label, so _src/_dst is what
-        # distinguishes them from nodes.
-        return isinstance(value, dict) and _has_meta(value, "_label") and not _has_meta(value, "_src")
+    # Backend shape handling — which driver returns what, and why each spelling
+    # has to be accepted — lives in utils/graph_shapes, shared with the live
+    # web renderer in viz/server.py so the two cannot drift apart again.
+    _meta = graph_shapes.meta
+    _has_meta = graph_shapes.has_meta
+    _is_relationship = graph_shapes.is_relationship
+    _is_node = graph_shapes.is_node
 
     def _node_payload(value) -> Dict[str, Any]:
         if hasattr(value, "labels"):
@@ -709,10 +686,19 @@ def _render_offline_visualization(
             node_id = _meta(value, "_id")
         if node_id is None:
             node_id = props.get("path") or props.get("name")
+        
+        name = props.get("name") or props.get("path") or ""
+        if name == "<module>":
+            _fpath = props.get("path") or props.get("file_path") or ""
+            if _fpath:
+                name = Path(_fpath).name
+            else:
+                name = "<module>"
+
         return {
             "id": _ident(node_id),
             "label": label,
-            "name": props.get("name") or props.get("path") or "",
+            "name": name,
             "file_path": props.get("path", ""),
             "line_number": props.get("line_number"),
         }

codegraphcontext/cli/main.py

@@ -2546,16 +2546,17 @@ def find_by_decorator_search(
 
 @find_app.command("argument")
 def find_by_argument_search(
-    argument: str = typer.Argument(..., help="Argument/parameter name to search for"),
+    argument: str = typer.Argument(..., help="Argument/parameter name or type to search for"),
     file: Optional[str] = typer.Option(None, "--file", "-f", help="Specific file path"),
     context: Optional[str] = typer.Option(None, "--context", "-c", help="Specific context to use"),
 ):
     """
-    Find functions that take a specific argument/parameter.
+    Find functions that take a specific argument/parameter name or type.
     
     Examples:
         cgc find argument password
         cgc find argument user_id --file src/auth.py
+        cgc find argument OrderFilter
     """
     _load_credentials()
     services = _initialize_services(context)
@@ -2571,7 +2572,7 @@ def find_by_argument_search(
             results = results[:req_limit]
         
         if not results:
-            console.print(f"[yellow]No functions found with argument '{argument}'[/yellow]")
+            console.print(f"[yellow]No functions found with argument name or type '{argument}'[/yellow]")
             return
             
         table = Table(show_header=True, header_style="bold magenta", box=box.ROUNDED)
@@ -3635,6 +3636,8 @@ def datasource_mysql(
     database: str = typer.Option(..., "--database", "-d", help="Database / schema name"),
     name: Optional[str] = typer.Option(None, "--name", "-n", help="Logical datasource name (default: mysql-<database>)"),
     env: str = typer.Option("production", "--env", "-e", help="Deployment environment label"),
+    ssl_verify: bool = typer.Option(False, "--ssl-verify", help="Connect over TLS and verify the server certificate (#1094)"),
+    ssl_ca_certs: Optional[str] = typer.Option(None, "--ssl-ca-certs", help="CA bundle path for --ssl-verify (default: system trust store)"),
     context: Optional[str] = typer.Option(None, "--context", "-c", help="CGC context to use"),
 ):
     """Ingest Aurora MySQL schema (tables + columns) and write to the code graph.
@@ -3650,7 +3653,8 @@ def datasource_mysql(
     console.print(f"[cyan]Connecting to Aurora MySQL at {host}:{port}/{database}...[/cyan]")
     try:
         result = mysql_ingest(host=host, port=port, user=user, password=password,
-                               database=database, name=name, env=env)
+                               database=database, name=name, env=env,
+                               ssl_verify=ssl_verify, ssl_ca_certs=ssl_ca_certs)
     except Exception as exc:
         console.print(f"[red]Failed to connect / ingest:[/red] {exc}")
         raise typer.Exit(1)
@@ -3672,6 +3676,8 @@ def datasource_cassandra(
     password: Optional[str] = typer.Option(None, "--password", "-P", help="Cassandra password", hide_input=True),
     name: Optional[str] = typer.Option(None, "--name", "-n", help="Logical datasource name (default: cassandra-<keyspace>)"),
     env: str = typer.Option("production", "--env", "-e", help="Deployment environment label"),
+    ssl_verify: bool = typer.Option(False, "--ssl-verify", help="Connect over TLS and verify the server certificate (#1094)"),
+    ssl_ca_certs: Optional[str] = typer.Option(None, "--ssl-ca-certs", help="CA bundle path for --ssl-verify (default: system trust store)"),
     context: Optional[str] = typer.Option(None, "--context", "-c", help="CGC context to use"),
 ):
     """Ingest Cassandra keyspace schema (tables + columns) and write to the code graph.
@@ -3688,7 +3694,8 @@ def datasource_cassandra(
     console.print(f"[cyan]Connecting to Cassandra at {hosts}/{keyspace}...[/cyan]")
     try:
         result = cassandra_ingest(hosts=hosts, port=port, keyspace=keyspace,
-                                   username=username, password=password, name=name, env=env)
+                                   username=username, password=password, name=name, env=env,
+                                   ssl_verify=ssl_verify, ssl_ca_certs=ssl_ca_certs)
     except Exception as exc:
         console.print(f"[red]Failed to connect / ingest:[/red] {exc}")
         raise typer.Exit(1)

codegraphcontext/cli/setup_wizard.py

@@ -7,6 +7,7 @@ import os
 from pathlib import Path
 import time
 import json
+import re
 import sys
 import shutil
 import yaml 
@@ -15,6 +16,48 @@ from codegraphcontext.cli.config_manager import normalize_config_path
 
 console = Console()
 
+def _strip_jsonc(text: str) -> str:
+    """Drop // and /* */ comments and trailing commas from a JSONC document.
+
+    VS Code and its forks write settings.json as JSONC. json.loads rejects both,
+    and treating that rejection as "no settings yet" discards the user's file.
+    """
+    out = []
+    i, n = 0, len(text)
+    in_string = escaped = False
+    while i < n:
+        ch = text[i]
+        if in_string:
+            out.append(ch)
+            if escaped:
+                escaped = False
+            elif ch == "\\":
+                escaped = True
+            elif ch == '"':
+                in_string = False
+            i += 1
+            continue
+        if ch == '"':
+            in_string = True
+            out.append(ch)
+            i += 1
+            continue
+        if text.startswith("//", i):
+            i = text.find("\n", i)
+            if i == -1:
+                break
+            continue
+        if text.startswith("/*", i):
+            end = text.find("*/", i + 2)
+            i = n if end == -1 else end + 2
+            continue
+        out.append(ch)
+        i += 1
+    stripped = "".join(out)
+    # A trailing comma before } or ] is legal JSONC, not JSON.
+    return re.sub(r",(\s*[}\]])", r"\1", stripped)
+
+
 def _check_write_access(path: Path) -> bool:
     target = path if path.exists() else path.parent
 
@@ -483,12 +526,26 @@ def _configure_ide(mcp_config):
 
         console.print(f"Using configuration file at: {target_path}")
         
+        had_comments = False
         try:
-            with open(target_path, "r") as f:
+            raw = target_path.read_text()
+            try:
+                settings = json.loads(raw)
+            except json.JSONDecodeError:
                 try:
-                    settings = json.load(f)
+                    settings = json.loads(_strip_jsonc(raw))
+                    had_comments = True
                 except json.JSONDecodeError:
-                    settings = {}
+                    # Never fall back to {}: this file gets written back below, so
+                    # treating an unreadable file as an empty one destroys it.
+                    console.print(
+                        f"[bold red]Could not parse {target_path}.[/bold red] "
+                        "Leaving it untouched so nothing is lost."
+                    )
+                    console.print(
+                        "Please add the MCP configuration manually from the `mcp.json` file generated above."
+                    )
+                    return
         except FileNotFoundError:
             settings = {}
 
@@ -515,6 +572,15 @@ def _configure_ide(mcp_config):
                 )
                 return
 
+            if target_path.exists():
+                backup_path = target_path.with_suffix(target_path.suffix + ".cgc-backup")
+                shutil.copy2(target_path, backup_path)
+                console.print(f"[dim]Backed up existing configuration to {backup_path}[/dim]")
+            if had_comments:
+                console.print(
+                    "[yellow]Note: this file contained comments. JSON output cannot keep them, "
+                    "so they are dropped in the rewritten file (the backup above still has them).[/yellow]"
+                )
             try:
                 with open(target_path, "w") as f:
                     json.dump(settings, f, indent=2)

codegraphcontext/core/cgcignore.py

@@ -64,6 +64,32 @@ def find_cgcignore(ignore_root: Path, explicit_path: Optional[str] = None) -> Op
         return explicit_candidate
     return None
 
+def find_gitignore(ignore_root: Path) -> Optional[Path]:
+    """Find a repository-local .gitignore, searched the same way as .cgcignore.
+
+    Bounded to the git worktree for the same reason find_cgcignore is: an indexed
+    path outside a repo must not pick up something like /tmp/.gitignore.
+    """
+    git_root: Optional[Path] = None
+    probe = ignore_root
+    while True:
+        if (probe / ".git").exists():
+            git_root = probe
+            break
+        if probe.parent == probe:
+            break
+        probe = probe.parent
+
+    curr = ignore_root
+    while True:
+        candidate = curr / ".gitignore"
+        if candidate.is_file():
+            return candidate
+        if git_root is None or curr == git_root:
+            return None
+        curr = curr.parent
+
+
 def ensure_default_cgcignore(path: Path, default_patterns: list[str]) -> None:
     """Create a .cgcignore file with default patterns when it does not exist."""
     path.parent.mkdir(parents=True, exist_ok=True)
@@ -265,9 +291,23 @@ def build_ignore_spec(
             parse_cgcignore_lines(explicit_cgcignore_path.read_text(encoding="utf-8").splitlines())
         )
 
+    gitignore_patterns: list[str] = []
+    gitignore_path = find_gitignore(ignore_root)
+    if gitignore_path is not None:
+        try:
+            gitignore_patterns = parse_cgcignore_lines(
+                gitignore_path.read_text(encoding="utf-8").splitlines()
+            )
+        except OSError as e:
+            warning_logger(f"Failed to read {gitignore_path}: {e}")
+
     # Defaults first, user patterns last: matching is last-match-wins (see
     # CGCIgnoreMatcher.match_file), so appending the defaults would make them
     # unconditionally override the user's rules and leave `!build/` with no way
     # to re-include a directory the built-in list ignores.
-    all_patterns = list(default_patterns) + merged_user_patterns
+    #
+    # .gitignore sits between the two for the same reason: what git ignores is
+    # ignored by default, while a `!pattern` in .cgcignore can still bring a
+    # git-ignored path back into the graph.
+    all_patterns = list(default_patterns) + gitignore_patterns + merged_user_patterns
     return CGCIgnoreMatcher(all_patterns, ignore_root), local_cgcignore_path

codegraphcontext/core/database_embedded_kuzu.py

@@ -174,7 +174,7 @@ class EmbeddedGraphManager(GraphQueryInterface):
             ("Directory", "path STRING, name STRING, PRIMARY KEY (path)"),
             ("Module", "name STRING, lang STRING, full_import_name STRING, path STRING, line_number INT64, PRIMARY KEY (name)"),
             # For types with composite keys (name, path, line_number), we use a 'uid'
-            ("Function", "uid STRING, name STRING, path STRING, line_number INT64, occurrence_index INT64, end_line INT64, source STRING, docstring STRING, lang STRING, cyclomatic_complexity INT64, context STRING, context_type STRING, class_context STRING, class_context_line INT64, module_context STRING, is_dependency BOOLEAN, decorators STRING[], args STRING[], http_method STRING, http_path STRING, embedding DOUBLE[], visibility STRING, modifiers STRING[], is_composable BOOLEAN, PRIMARY KEY (uid)"),
+            ("Function", "uid STRING, name STRING, path STRING, line_number INT64, occurrence_index INT64, end_line INT64, source STRING, docstring STRING, lang STRING, cyclomatic_complexity INT64, context STRING, context_type STRING, class_context STRING, class_context_line INT64, module_context STRING, is_dependency BOOLEAN, decorators STRING[], args STRING[], arg_types STRING[], http_method STRING, http_path STRING, embedding DOUBLE[], visibility STRING, modifiers STRING[], is_composable BOOLEAN, PRIMARY KEY (uid)"),
             ("Class", "uid STRING, name STRING, path STRING, line_number INT64, occurrence_index INT64, end_line INT64, source STRING, docstring STRING, lang STRING, node_type STRING, is_dependency BOOLEAN, decorators STRING[], visibility STRING, modifiers STRING[], PRIMARY KEY (uid)"),
             ("Variable", "uid STRING, name STRING, path STRING, line_number INT64, occurrence_index INT64, source STRING, docstring STRING, lang STRING, value STRING, context STRING, is_dependency BOOLEAN, PRIMARY KEY (uid)"),
             ("Trait", "uid STRING, name STRING, path STRING, line_number INT64, occurrence_index INT64, end_line INT64, source STRING, docstring STRING, lang STRING, is_dependency BOOLEAN, PRIMARY KEY (uid)"),
@@ -385,6 +385,7 @@ class EmbeddedGraphManager(GraphQueryInterface):
             ("Function", "is_composable", "BOOLEAN"),
             ("Function", "http_method", "STRING"),
             ("Function", "http_path", "STRING"),
+            ("Function", "arg_types", "STRING[]"),
             # Kotlin/JVM precision improvements
             ("Function", "class_context_line", "INT64"),
             ("Function", "module_context", "STRING"),
@@ -915,7 +916,7 @@ class EmbeddedSessionWrapper:
             'File': {'path', 'name', 'relative_path', 'package_name', 'language', 'is_dependency'},
             'Directory': {'path', 'name'},
             'Module': {'name', 'lang', 'full_import_name', 'path', 'line_number'},
-            'Function': {'uid', 'name', 'path', 'line_number', 'occurrence_index', 'end_line', 'source', 'docstring', 'lang', 'cyclomatic_complexity', 'context', 'context_type', 'class_context', 'class_context_line', 'module_context', 'is_dependency', 'decorators', 'args', 'http_method', 'http_path', 'visibility', 'modifiers', 'is_composable'},
+            'Function': {'uid', 'name', 'path', 'line_number', 'occurrence_index', 'end_line', 'source', 'docstring', 'lang', 'cyclomatic_complexity', 'context', 'context_type', 'class_context', 'class_context_line', 'module_context', 'is_dependency', 'decorators', 'args', 'arg_types', 'http_method', 'http_path', 'visibility', 'modifiers', 'is_composable'},
             'Class': {'uid', 'name', 'path', 'line_number', 'occurrence_index', 'end_line', 'source', 'docstring', 'lang', 'node_type', 'is_dependency', 'decorators', 'visibility', 'modifiers'},
             'Variable': {'uid', 'name', 'path', 'line_number', 'occurrence_index', 'source', 'docstring', 'lang', 'value', 'context', 'is_dependency'},
             'Trait': {'uid', 'name', 'path', 'line_number', 'occurrence_index', 'end_line', 'source', 'docstring', 'lang', 'is_dependency'},

codegraphcontext/tool_definitions.py

@@ -110,7 +110,7 @@ TOOLS = {
                 },
                 "target": {
                     "type": "string",
-                    "description": "The primary target for the query (e.g., function name, class name, or 'start_func->end_func' for call chains)."
+                    "description": "The primary query target (for example, a function name, class name, or 'start_func->end_func' for call chains). For find_functions_by_argument, use a parameter name or type."
                 },
                 "context": {
                     "type": "string",

codegraphcontext/tools/code_finder.py

@@ -635,35 +635,36 @@ class CodeFinder:
         return results
     
     def find_functions_by_argument(self, argument_name: str, path: Optional[str] = None, repo_path: Optional[str] = None, limit: Optional[int] = None) -> List[Dict]:
-        """Find functions that take a specific argument name."""
+        """Find functions that take a specific argument name or type."""
         repo_path = self._normalize_repo_path_filter(repo_path)
         with self.driver.session() as session:
+            path_filter = "AND f.path = $path" if path else ""
             repo_filter = "AND f.path STARTS WITH $repo_path" if repo_path else ""
             limit_clause = "LIMIT $limit" if limit is not None else ""
             params = {"argument_name": argument_name, "repo_path": repo_path}
-            if limit is not None:
-                params["limit"] = limit
             if path:
                 params["path"] = path
-                query = f"""
-                    MATCH (f:Function)-[:HAS_PARAMETER]->(p:Parameter)
-                    WHERE p.name = $argument_name AND f.path = $path {repo_filter}
-                    RETURN f.name AS function_name, f.path AS path, f.line_number AS line_number,
-                           f.docstring AS docstring, f.is_dependency AS is_dependency
-                    ORDER BY f.is_dependency ASC, f.path, f.line_number
-                    {limit_clause}
-                """
-                result = session.run(query, **params)
-            else:
-                query = f"""
-                    MATCH (f:Function)-[:HAS_PARAMETER]->(p:Parameter)
-                    WHERE p.name = $argument_name {repo_filter}
-                    RETURN f.name AS function_name, f.path AS path, f.line_number AS line_number,
-                           f.docstring AS docstring, f.is_dependency AS is_dependency
-                    ORDER BY f.is_dependency ASC, f.path, f.line_number
-                    {limit_clause}
-                """
-                result = session.run(query, **params)
+            if limit is not None:
+                params["limit"] = limit
+
+            # A WHERE attached to an OPTIONAL MATCH only constrains the
+            # optional part — it can never filter f, so the original form
+            # returned EVERY function for any search term. Filter f itself
+            # after materializing the optional parameter match.
+            query = f"""
+                MATCH (f:Function)
+                WHERE 1=1 {path_filter} {repo_filter}
+                OPTIONAL MATCH (f)-[:HAS_PARAMETER]->(p:Parameter {{name: $argument_name}})
+                WITH DISTINCT f, p
+                WHERE p IS NOT NULL
+                   OR (f.arg_types IS NOT NULL AND $argument_name IN f.arg_types)
+                RETURN DISTINCT f.name AS function_name, f.path AS path,
+                       f.line_number AS line_number, f.docstring AS docstring,
+                       f.is_dependency AS is_dependency
+                ORDER BY is_dependency ASC, path, line_number
+                {limit_clause}
+            """
+            result = session.run(query, **params)
             return result.data()
 
     def find_functions_by_decorator(self, decorator_name: str, path: Optional[str] = None, repo_path: Optional[str] = None, limit: Optional[int] = None) -> List[Dict]:

codegraphcontext/tools/datasources/cassandra_ingester.py

@@ -1,100 +1,119 @@
-# src/codegraphcontext/tools/datasources/cassandra_ingester.py
-"""Cassandra schema ingester (#843).
-
-Pulls keyspace + table + column metadata from system_schema and writes
-Datasource / DbTable / DbColumn nodes.
-
-Requires: pip install cassandra-driver
-"""
-
-from __future__ import annotations
-
-from typing import Any, Dict, List, Optional
-
-
-def ingest(
-    hosts: List[str],
-    port: int,
-    keyspace: str,
-    username: Optional[str] = None,
-    password: Optional[str] = None,
-    name: Optional[str] = None,
-    env: str = "production",
-) -> Dict[str, Any]:
-    """Fetch schema from Cassandra system_schema and return a datasource graph dict.
-
-    Returns:
-        {
-            datasource: {name, kind, host, env, keyspace},
-            tables:     [{name, fqn, datasource_name}],
-            columns:    [{name, type, nullable, table_fqn, datasource_name}],
-        }
-    """
-    try:
-        from cassandra.cluster import Cluster
-        from cassandra.auth import PlainTextAuthProvider
-    except ImportError:
-        raise ImportError(
-            "Cassandra driver not found. Install with: pip install cassandra-driver"
-        )
-
-    datasource_name = name or f"cassandra-{keyspace}"
-
-    auth_provider = None
-    if username and password:
-        auth_provider = PlainTextAuthProvider(username=username, password=password)
-
-    cluster = Cluster(hosts, port=port, auth_provider=auth_provider)
-    session = cluster.connect()
-
-    try:
-        tables: List[Dict[str, Any]] = []
-        columns: List[Dict[str, Any]] = []
-
-        # Tables from system_schema
-        rows = session.execute(
-            "SELECT table_name, comment FROM system_schema.tables WHERE keyspace_name = %s",
-            (keyspace,),
-        )
-        for row in rows:
-            fqn = f"{keyspace}.{row.table_name}"
-            tables.append({
-                "name": row.table_name,
-                "fqn": fqn,
-                "datasource_name": datasource_name,
-                "comment": getattr(row, "comment", ""),
-            })
-
-        # Columns from system_schema
-        rows = session.execute(
-            """SELECT table_name, column_name, type, kind
-               FROM system_schema.columns
-               WHERE keyspace_name = %s""",
-            (keyspace,),
-        )
-        for row in rows:
-            table_fqn = f"{keyspace}.{row.table_name}"
-            columns.append({
-                "name": row.column_name,
-                "type": row.type,
-                "nullable": True,  # Cassandra columns are always nullable except PK
-                "table_fqn": table_fqn,
-                "datasource_name": datasource_name,
-                "is_primary_key": row.kind in ("partition_key", "clustering"),
-            })
-
-    finally:
-        session.shutdown()
-        cluster.shutdown()
-
-    return {
-        "datasource": {
-            "name": datasource_name,
-            "kind": "cassandra",
-            "host": hosts[0],
-            "env": env,
-            "keyspace": keyspace,
-        },
-        "tables": tables,
-        "columns": columns,
-    }
+# src/codegraphcontext/tools/datasources/cassandra_ingester.py
+"""Cassandra schema ingester (#843).
+
+Pulls keyspace + table + column metadata from system_schema and writes
+Datasource / DbTable / DbColumn nodes.
+
+Requires: pip install cassandra-driver
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+
+def ingest(
+    hosts: List[str],
+    port: int,
+    keyspace: str,
+    username: Optional[str] = None,
+    password: Optional[str] = None,
+    name: Optional[str] = None,
+    env: str = "production",
+    ssl_verify: bool = False,
+    ssl_ca_certs: Optional[str] = None,
+) -> Dict[str, Any]:
+    """Fetch schema from Cassandra system_schema and return a datasource graph dict.
+
+    Returns:
+        {
+            datasource: {name, kind, host, env, keyspace},
+            tables:     [{name, fqn, datasource_name}],
+            columns:    [{name, type, nullable, table_fqn, datasource_name}],
+        }
+    """
+    try:
+        from cassandra.cluster import Cluster
+        from cassandra.auth import PlainTextAuthProvider
+    except ImportError:
+        raise ImportError(
+            "Cassandra driver not found. Install with: pip install cassandra-driver"
+        )
+
+    datasource_name = name or f"cassandra-{keyspace}"
+
+    auth_provider = None
+    if username and password:
+        auth_provider = PlainTextAuthProvider(username=username, password=password)
+
+    ssl_context = None
+    if ssl_verify:
+        import ssl
+
+        ssl_context = ssl.create_default_context(
+            cafile=ssl_ca_certs if ssl_ca_certs else None
+        )
+        if not ssl_ca_certs:
+            # No explicit CA bundle: verify against system trust store.
+            ssl_context.verify_mode = ssl.CERT_REQUIRED
+            ssl_context.check_hostname = True
+
+    cluster = Cluster(
+        hosts,
+        port=port,
+        auth_provider=auth_provider,
+        ssl_context=ssl_context,
+    )
+    session = cluster.connect()
+
+    try:
+        tables: List[Dict[str, Any]] = []
+        columns: List[Dict[str, Any]] = []
+
+        # Tables from system_schema
+        rows = session.execute(
+            "SELECT table_name, comment FROM system_schema.tables WHERE keyspace_name = %s",
+            (keyspace,),
+        )
+        for row in rows:
+            fqn = f"{keyspace}.{row.table_name}"
+            tables.append({
+                "name": row.table_name,
+                "fqn": fqn,
+                "datasource_name": datasource_name,
+                "comment": getattr(row, "comment", ""),
+            })
+
+        # Columns from system_schema
+        rows = session.execute(
+            """SELECT table_name, column_name, type, kind
+               FROM system_schema.columns
+               WHERE keyspace_name = %s""",
+            (keyspace,),
+        )
+        for row in rows:
+            table_fqn = f"{keyspace}.{row.table_name}"
+            columns.append({
+                "name": row.column_name,
+                "type": row.type,
+                "nullable": True,  # Cassandra columns are always nullable except PK
+                "table_fqn": table_fqn,
+                "datasource_name": datasource_name,
+                "is_primary_key": row.kind in ("partition_key", "clustering"),
+            })
+
+    finally:
+        session.shutdown()
+        cluster.shutdown()
+
+    return {
+        "datasource": {
+            "name": datasource_name,
+            "kind": "cassandra",
+            "host": hosts[0],
+            "env": env,
+            "keyspace": keyspace,
+        },
+        "tables": tables,
+        "columns": columns,
+    }

codegraphcontext/tools/datasources/mysql_ingester.py

@@ -1,121 +1,143 @@
-# src/codegraphcontext/tools/datasources/mysql_ingester.py
-"""Aurora MySQL schema ingester (#843).
-
-Pulls table + column metadata from information_schema and writes
-Datasource / DbTable / DbColumn nodes with HAS_COLUMN and STORED_IN edges.
-
-Requires: pip install PyMySQL  (or mysql-connector-python)
-Connection URI:  mysql://user:pass@host:3306/database
-"""
-
-from __future__ import annotations
-
-from typing import Any, Dict, List, Optional
-
-
-def _connect(host: str, port: int, user: str, password: str, database: str) -> Any:
-    """Return a DB-API 2.0 connection. Tries PyMySQL then mysql-connector-python."""
-    try:
-        import pymysql
-        return pymysql.connect(
-            host=host, port=port, user=user, password=password, database=database,
-            cursorclass=pymysql.cursors.DictCursor, connect_timeout=10,
-        )
-    except ImportError:
-        pass
-    try:
-        import mysql.connector
-        return mysql.connector.connect(
-            host=host, port=port, user=user, password=password, database=database,
-            connection_timeout=10,
-        )
-    except ImportError:
-        raise ImportError(
-            "MySQL driver not found. Install with: pip install PyMySQL"
-        )
-
-
-def ingest(
-    host: str,
-    port: int,
-    user: str,
-    password: str,
-    database: str,
-    name: Optional[str] = None,
-    env: str = "production",
-) -> Dict[str, Any]:
-    """Fetch schema from Aurora MySQL and return a datasource graph dict.
-
-    Returns:
-        {
-            datasource: {name, kind, host, env, database},
-            tables:     [{name, fqn, datasource_name}],
-            columns:    [{name, type, nullable, table_fqn, datasource_name}],
-        }
-    """
-    datasource_name = name or f"mysql-{database}"
-    conn = _connect(host, port, user, password, database)
-
-    try:
-        tables: List[Dict[str, Any]] = []
-        columns: List[Dict[str, Any]] = []
-
-        with conn.cursor() as cur:
-            # Tables
-            cur.execute(
-                """
-                SELECT TABLE_NAME, TABLE_TYPE, TABLE_ROWS, TABLE_COMMENT
-                FROM information_schema.TABLES
-                WHERE TABLE_SCHEMA = %s
-                ORDER BY TABLE_NAME
-                """,
-                (database,),
-            )
-            for row in cur.fetchall():
-                fqn = f"{database}.{row['TABLE_NAME']}"
-                tables.append({
-                    "name": row["TABLE_NAME"],
-                    "fqn": fqn,
-                    "datasource_name": datasource_name,
-                    "table_type": row.get("TABLE_TYPE", "BASE TABLE"),
-                    "estimated_rows": row.get("TABLE_ROWS"),
-                    "comment": row.get("TABLE_COMMENT", ""),
-                })
-
-            # Columns
-            cur.execute(
-                """
-                SELECT TABLE_NAME, COLUMN_NAME, DATA_TYPE, IS_NULLABLE,
-                       COLUMN_DEFAULT, COLUMN_COMMENT, COLUMN_KEY
-                FROM information_schema.COLUMNS
-                WHERE TABLE_SCHEMA = %s
-                ORDER BY TABLE_NAME, ORDINAL_POSITION
-                """,
-                (database,),
-            )
-            for row in cur.fetchall():
-                table_fqn = f"{database}.{row['TABLE_NAME']}"
-                columns.append({
-                    "name": row["COLUMN_NAME"],
-                    "type": row["DATA_TYPE"],
-                    "nullable": row["IS_NULLABLE"] == "YES",
-                    "table_fqn": table_fqn,
-                    "datasource_name": datasource_name,
-                    "is_primary_key": row.get("COLUMN_KEY") == "PRI",
-                    "comment": row.get("COLUMN_COMMENT", ""),
-                })
-
-    finally:
-        conn.close()
-
-    return {
-        "datasource": {
-            "name": datasource_name,
-            "kind": "mysql",
-            "host": host,
-            "env": env,
-            "database": database,
-        },
-        "tables": tables,
-        "columns": columns,
-    }
+# src/codegraphcontext/tools/datasources/mysql_ingester.py
+"""Aurora MySQL schema ingester (#843).
+
+Pulls table + column metadata from information_schema and writes
+Datasource / DbTable / DbColumn nodes with HAS_COLUMN and STORED_IN edges.
+
+Requires: pip install PyMySQL  (or mysql-connector-python)
+Connection URI:  mysql://user:pass@host:3306/database
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+
+def _connect(
+    host: str,
+    port: int,
+    user: str,
+    password: str,
+    database: str,
+    ssl_verify: bool = False,
+    ssl_ca_certs: Optional[str] = None,
+) -> Any:
+    """Return a DB-API 2.0 connection. Tries PyMySQL then mysql-connector-python."""
+    ssl_kwargs: Dict[str, Any] = {}
+    if ssl_verify:
+        ssl_kwargs["ssl"] = {
+            "ca": ssl_ca_certs if ssl_ca_certs else None,
+            "check_hostname": True,
+            "verify_mode": "REQUIRED",
+        }
+    try:
+        import pymysql
+        return pymysql.connect(
+            host=host, port=port, user=user, password=password, database=database,
+            cursorclass=pymysql.cursors.DictCursor, connect_timeout=10,
+            **ssl_kwargs,
+        )
+    except ImportError:
+        pass
+    try:
+        import mysql.connector
+        conn_kwargs = dict(
+            host=host, port=port, user=user, password=password, database=database,
+            connection_timeout=10,
+        )
+        if ssl_verify:
+            conn_kwargs["ssl_ca"] = ssl_ca_certs if ssl_ca_certs else None
+            conn_kwargs["ssl_verify_cert"] = True
+        return mysql.connector.connect(**conn_kwargs)
+    except ImportError:
+        raise ImportError(
+            "MySQL driver not found. Install with: pip install PyMySQL"
+        )
+
+
+def ingest(
+    host: str,
+    port: int,
+    user: str,
+    password: str,
+    database: str,
+    name: Optional[str] = None,
+    env: str = "production",
+    ssl_verify: bool = False,
+    ssl_ca_certs: Optional[str] = None,
+) -> Dict[str, Any]:
+    """Fetch schema from Aurora MySQL and return a datasource graph dict.
+
+    Returns:
+        {
+            datasource: {name, kind, host, env, database},
+            tables:     [{name, fqn, datasource_name}],
+            columns:    [{name, type, nullable, table_fqn, datasource_name}],
+        }
+    """
+    datasource_name = name or f"mysql-{database}"
+    conn = _connect(host, port, user, password, database, ssl_verify, ssl_ca_certs)
+
+    try:
+        tables: List[Dict[str, Any]] = []
+        columns: List[Dict[str, Any]] = []
+
+        with conn.cursor() as cur:
+            # Tables
+            cur.execute(
+                """
+                SELECT TABLE_NAME, TABLE_TYPE, TABLE_ROWS, TABLE_COMMENT
+                FROM information_schema.TABLES
+                WHERE TABLE_SCHEMA = %s
+                ORDER BY TABLE_NAME
+                """,
+                (database,),
+            )
+            for row in cur.fetchall():
+                fqn = f"{database}.{row['TABLE_NAME']}"
+                tables.append({
+                    "name": row["TABLE_NAME"],
+                    "fqn": fqn,
+                    "datasource_name": datasource_name,
+                    "table_type": row.get("TABLE_TYPE", "BASE TABLE"),
+                    "estimated_rows": row.get("TABLE_ROWS"),
+                    "comment": row.get("TABLE_COMMENT", ""),
+                })
+
+            # Columns
+            cur.execute(
+                """
+                SELECT TABLE_NAME, COLUMN_NAME, DATA_TYPE, IS_NULLABLE,
+                       COLUMN_DEFAULT, COLUMN_COMMENT, COLUMN_KEY
+                FROM information_schema.COLUMNS
+                WHERE TABLE_SCHEMA = %s
+                ORDER BY TABLE_NAME, ORDINAL_POSITION
+                """,
+                (database,),
+            )
+            for row in cur.fetchall():
+                table_fqn = f"{database}.{row['TABLE_NAME']}"
+                columns.append({
+                    "name": row["COLUMN_NAME"],
+                    "type": row["DATA_TYPE"],
+                    "nullable": row["IS_NULLABLE"] == "YES",
+                    "table_fqn": table_fqn,
+                    "datasource_name": datasource_name,
+                    "is_primary_key": row.get("COLUMN_KEY") == "PRI",
+                    "comment": row.get("COLUMN_COMMENT", ""),
+                })
+
+    finally:
+        conn.close()
+
+    return {
+        "datasource": {
+            "name": datasource_name,
+            "kind": "mysql",
+            "host": host,
+            "env": env,
+            "database": database,
+        },
+        "tables": tables,
+        "columns": columns,
+    }

codegraphcontext/tools/handlers/management_handlers.py

@@ -98,6 +98,8 @@ def check_job_status(job_manager: JobManager, **args) -> Dict[str, Any]:
         job_dict["start_time"] = job.start_time.strftime("%Y-%m-%d %H:%M:%S")
         if job.end_time:
             job_dict["end_time"] = job.end_time.strftime("%Y-%m-%d %H:%M:%S")
+        if job.last_update_time:
+            job_dict["last_update_time"] = job.last_update_time.strftime("%Y-%m-%d %H:%M:%S")
         
         job_dict["status"] = job.status.value
         
@@ -119,6 +121,8 @@ def list_jobs(job_manager: JobManager) -> Dict[str, Any]:
             job_dict["start_time"] = job.start_time.strftime("%Y-%m-%d %H:%M:%S")
             if job.end_time:
                 job_dict["end_time"] = job.end_time.strftime("%Y-%m-%d %H:%M:%S")
+            if job.last_update_time:
+                job_dict["last_update_time"] = job.last_update_time.strftime("%Y-%m-%d %H:%M:%S")
             jobs_data.append(job_dict)
         
         jobs_data.sort(key=lambda x: x["start_time"], reverse=True)

codegraphcontext/utils/graph_shapes.py

@@ -0,0 +1,123 @@
+"""Backend-agnostic classification of values returned by a graph driver.
+
+CodeGraphContext renders the same graph through two independent paths — the
+offline renderer in ``cli/cli_helpers.py`` and the live web server in
+``viz/server.py``. Each supported backend hands back a different shape, so both
+paths need to answer the same question: *is this value a node or a
+relationship?*
+
+Until now each path answered it separately, and they drifted:
+
+* ``cli_helpers`` classified by **duck typing** (does the value expose
+  ``.labels``? ``.relation``/``.src_node``?), which covers any driver.
+* ``viz/server`` classified by **class name**, matching only
+  ``Node``/``KuzuNode`` and ``Relationship``/``KuzuRelationship``.
+
+FalkorDB's edge class is named ``Edge``, so it matched neither branch in the
+server path and every FalkorDB relationship was silently discarded — on the
+backend that is CGC's *default* on Unix under Python 3.12+. The server's own
+``parse_rel`` already knew how to read a FalkorDB edge; it was simply never
+reached.
+
+Both paths now share the predicates below, so *classification* cannot drift
+apart again. Id and property extraction are still duplicated between
+``viz/server.parse_node``/``parse_rel`` and ``cli_helpers``' payload builders —
+consolidating those is deliberately left out of this change.
+
+Shapes, confirmed by querying each backend's real Python package:
+
+``neo4j``
+    ``Node`` carries ``.labels`` and is dict-convertible via the Mapping
+    protocol. ``Relationship`` carries ``.type`` plus ``.start_node`` /
+    ``.end_node`` (full ``Node`` objects).
+
+``falkordb``
+    ``Node`` carries ``.labels`` but is **not** dict-convertible — properties
+    live in a plain ``.properties`` dict. ``Edge`` carries ``.relation`` plus
+    ``.src_node`` / ``.dest_node``, which hold the bare integer node ids, and
+    exposes no ``.labels`` and no ``.type``.
+
+``kuzu`` / ``ladybug``
+    Plain dicts. Nodes carry ``_id`` / ``_label``; relationships carry
+    ``_src`` / ``_dst`` / ``_label``. Kùzu spells these keys lowercase and
+    Ladybug spells the identical fields uppercase (``_ID`` / ``_LABEL`` /
+    ``_SRC`` / ``_DST``), so every lookup here accepts either casing.
+"""
+
+from typing import Any
+
+__all__ = ["has_meta", "meta", "is_node", "is_relationship"]
+
+
+def has_meta(record: dict, key: str) -> bool:
+    """True if ``record`` carries ``key`` in either Kùzu or Ladybug casing."""
+    return key in record or key.upper() in record
+
+
+def meta(record: dict, key: str, default: Any = None) -> Any:
+    """Read an internal ``_``-prefixed field regardless of its casing."""
+    if key in record:
+        return record[key]
+    return record.get(key.upper(), default)
+
+
+def _is_driver_relationship(value: Any) -> bool:
+    """True for a driver object that looks like a relationship.
+
+    Neo4j exposes ``.type``; FalkorDB exposes ``.relation`` alongside
+    ``.src_node``. Both are checked because neither driver implements the
+    other's attribute.
+    """
+    if hasattr(value, "type"):
+        return True
+    return hasattr(value, "relation") and hasattr(value, "src_node")
+
+
+def is_relationship(value: Any) -> bool:
+    """True if ``value`` is a relationship from any supported backend."""
+    # ``.labels`` is the unambiguous node marker across every driver, so it
+    # settles the question before the relationship checks run.
+    if hasattr(value, "labels"):
+        return False
+    if _is_driver_relationship(value):
+        return True
+    if isinstance(value, dict):
+        # Kùzu and Ladybug relationships also carry ``_label``, so the
+        # endpoints are what distinguish them from nodes.
+        if has_meta(value, "_src") and has_meta(value, "_dst"):
+            return True
+        # A FalkorDB result mapped into a plain dict keeps the driver's
+        # endpoint names.
+        return "src_node" in value and "dest_node" in value
+    return False
+
+
+def _has_endpoint_marker(record: dict) -> bool:
+    """True if a dict carries any relationship-endpoint field.
+
+    A half-formed relationship — say ``_src`` present but ``_dst`` missing —
+    is not a usable relationship, but it must not be mistaken for a node
+    either: it also carries ``_label``, so a plain label check would turn it
+    into a phantom node with a relationship's id. Values like that are
+    classified as neither and skipped, which is what the offline renderer has
+    always done.
+    """
+    return (
+        has_meta(record, "_src")
+        or has_meta(record, "_dst")
+        or "src_node" in record
+        or "dest_node" in record
+    )
+
+
+def is_node(value: Any) -> bool:
+    """True if ``value`` is a node from any supported backend."""
+    if hasattr(value, "labels"):
+        return True
+    if _is_driver_relationship(value):
+        return False
+    if isinstance(value, dict):
+        if _has_endpoint_marker(value):
+            return False
+        return has_meta(value, "_label") or "labels" in value
+    return False

codegraphcontext/utils/visualize_graph.py

@@ -99,11 +99,15 @@ def build_graph_data(
     for node in nodes:
         node_id = node.get("id") or node.get("name", "unknown")
         label = node.get("label", "Function")
+        name = node.get("name", str(node_id))
+        file_path = node.get("file_path", "")
+        if name == "<module>" and file_path:
+            name = Path(file_path).name
         serialised_nodes.append({
             "id":        str(node_id),
             "label":     label,
-            "name":      node.get("name", str(node_id)),
-            "file_path": node.get("file_path", ""),
+            "name":      name,
+            "file_path": file_path,
             "line":      node.get("line_number"),
             "color":     node_color(label),
         })
@@ -362,7 +366,11 @@ def render_html(
         ctx.fillStyle = '#e2e8f0';
         ctx.font = '10px monospace';
         ctx.textAlign = 'center';
-        ctx.fillText(n.name.length > 16 ? n.name.slice(0,14)+'…' : n.name, p.x, p.y + 24);
+        let displayName = n.name;
+        if (displayName === '<module>' && n.file_path) {{
+          displayName = n.file_path.split('/').pop();
+        }}
+        ctx.fillText(displayName.length > 16 ? displayName.slice(0,14)+'…' : displayName, p.x, p.y + 24);
       }});
     }}
 

codegraphcontext/viz/server.py

@@ -20,6 +20,7 @@ if TYPE_CHECKING:
 from ..utils.debug_log import debug_log
 from ..utils.path_sandbox import is_path_allowed
 from ..utils.cypher_readonly import is_read_only_cypher as _is_read_only_cypher, read_only_rejection_message
+from ..utils import graph_shapes
 
 app = FastAPI()
 
@@ -236,6 +237,15 @@ async def get_graph(repo_path: Optional[str] = None, cypher_query: Optional[str]
                                 # Extract name/label for frontend
                                 # Prefer 'name' property, fallback to 'label', then 'path' or 'Unknown'
                                 display_name = str(props.get('name', props.get('label', props.get('path', 'Unknown'))))
+                                if display_name == "<module>":
+                                    _fpath = str(props.get('path', props.get('file', '')))
+                                    if _fpath:
+                                        # Same plain-filename label as the payload builders in
+                                        # cli_helpers/visualize_graph, so one node cannot
+                                        # render two different names in different views.
+                                        display_name = os.path.basename(_fpath)
+                                        props['name'] = display_name
+                                        props['label'] = display_name
                                 
                                 nodes_dict[eid] = {
                                     "id": eid,
@@ -469,6 +479,12 @@ def parse_node(node, nodes_dict):
             except: pass
             
     display_name = str(props.get('name', props.get('label', props.get('path', 'Unknown'))))
+    if display_name == "<module>":
+        _fpath = str(props.get('path', props.get('file', '')))
+        if _fpath:
+            display_name = os.path.basename(_fpath)
+            props['name'] = display_name
+            props['label'] = display_name
     
     nodes_dict[eid] = {
         "id": eid,
@@ -533,18 +549,13 @@ def parse_element(val, nodes_dict, edges):
             parse_element(r, nodes_dict, edges)
         return
         
-    type_name = type(val).__name__
-    
-    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:
+    # Classification is duck-typed and shared with the offline renderer (see
+    # utils/graph_shapes). Matching on class name used to miss FalkorDB's
+    # `Edge`, so every FalkorDB relationship was dropped here even though
+    # `parse_rel` below reads it correctly.
+    if graph_shapes.is_node(val):
         parse_node(val, nodes_dict)
-    elif type_name in ('Relationship', 'KuzuRelationship') or is_dict_rel:
+    elif graph_shapes.is_relationship(val):
         parse_rel(val, edges)
     elif isinstance(val, (list, tuple)):
         for item in val:

{codegraphcontext-0.6.8.dist-info → codegraphcontext-0.6.9.dist-info}/METADATA

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

@@ -3,7 +3,7 @@ codegraphcontext/__main__.py,sha256=21QjL_lfd6cy-clJYPBg6xKb_IuNDcvvWdaAJEvZ-HQ,
 codegraphcontext/prompts.py,sha256=aK_oe7DQwHNYtpjOy5aqi2VTKs4KJihwF6O4E8z3IPA,8603
 codegraphcontext/server.py,sha256=aaplzU_SlkVsPdwiyf6RvXnGqnkvDilvrbC_euUYcAU,37408
 codegraphcontext/stdlibs.py,sha256=sWcjgJyGIGewilnBt4qXogw2cH4YWwHWkEXbCSIv5Zc,283
-codegraphcontext/tool_definitions.py,sha256=BjUD5PKn7GcmgsPxD1-ba4SUr05iE5ueftqIX4Cwy7s,19938
+codegraphcontext/tool_definitions.py,sha256=11A_9cOo_l9vunBUcM8xcxZFJMBsKx2_U4-bMwcjfH8,20001
 codegraphcontext/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 codegraphcontext/api/app.py,sha256=pP-OaQUny0dsgfP7zj_ib3GqIfGh3zb7P1Gx6rKh0uw,3844
 codegraphcontext/api/auth.py,sha256=YnV4lKlBgyIP7HFQKKaD7kJZOXBe3gOoyovbhBWI7g8,4407
@@ -11,22 +11,22 @@ codegraphcontext/api/mcp_sse.py,sha256=cWu_dG4rkH8Teb4_BjKNGhkxXKumGaZdFahlT2uw5
 codegraphcontext/api/router.py,sha256=9XCm5FBZY4z-k8k9Z1OlE9vMdSK-bh6tC5_Qef1F1eA,4383
 codegraphcontext/api/schemas.py,sha256=pGLuKtdn55pf8mS8wv8MwehbT_3-4OZuSYjI5LJxzOc,1034
 codegraphcontext/cli/__init__.py,sha256=2vUlnf7H09M9JbS2gS_LmMUBJWAWcGGHkkl4I2YrdSg,39
-codegraphcontext/cli/cli_helpers.py,sha256=yB0N680PS49A6eYCisMJIotQDOpo38-FQ-VFfJQ33OQ,56067
+codegraphcontext/cli/cli_helpers.py,sha256=7fEJK0k85basOphCV9iO6zCh1pIONct3jj5ABE1cd2c,55334
 codegraphcontext/cli/config_manager.py,sha256=L4-Hun7bluTg5TWTyAUxLqTGTvPI6Z8oYVd2rnKEn8w,56113
 codegraphcontext/cli/hook_manager.py,sha256=nKr6SiuM6zA3eZv1rZSNPXUyqkha8Ja0VGQ3_145bLE,7615
-codegraphcontext/cli/main.py,sha256=rxcXzB9Wb6DDxqTXhyHtCQECIhl0_PTJmQy4xBG_EU4,162703
+codegraphcontext/cli/main.py,sha256=2d2kNSLbBgMFZaegWkT1UbZF68ApLDFPzZXu0FqvM6w,163479
 codegraphcontext/cli/project_config.py,sha256=Slae6fIojlcqRbFzRkAMAsglamryLCPrjUFG16e165g,7492
 codegraphcontext/cli/registry_commands.py,sha256=KwLwxKzMWs0tAFd__nPf_gz3kmlPO5b6Zcb_9Qkguf0,18516
 codegraphcontext/cli/setup_macos.py,sha256=0jcxRsQX7_UcfKrFUnc5Yx3m34w0C3w3x5n7KH6ty6g,3743
-codegraphcontext/cli/setup_wizard.py,sha256=NzNoWWeMrS-iSRPlrlCydEERo9YWp_eB1he_DkUGXSw,50566
+codegraphcontext/cli/setup_wizard.py,sha256=N958hdsypaE1gza3wEjJsZ3c-i888oRH5PYQkKD3dP4,53083
 codegraphcontext/cli/simulator.py,sha256=QSHLIP_iQsaoun52ipUpPl7inqlXKmQs6yddQHom42U,14564
 codegraphcontext/cli/visualizer.py,sha256=QJbxoIcUBgZ2pQP0tq0pxcM5xgT-CQtHWxD7xludK5k,5464
 codegraphcontext/core/__init__.py,sha256=jSr7aX-5OvFJGoKdx24bFA5-eMyBKhSrxrvJr32XG3g,14081
 codegraphcontext/core/bundle_registry.py,sha256=xlVBe-fmvEOLY9xDq7w0vXFlTPzeFVIwO9cqzBtVm4E,7490
 codegraphcontext/core/cgc_bundle.py,sha256=X2aOji754UyjvCEJc3hOQCP6KF_H4OJNQMfUunrYY5I,74714
-codegraphcontext/core/cgcignore.py,sha256=x50FOG04kmR12LqixTlfiHW4ka05jf6_jaRA-5yiqis,10847
+codegraphcontext/core/cgcignore.py,sha256=yJeRaPlDyOaSGGdXB5kwBlSqpEXtrqsSzo0UNMoqef8,12236
 codegraphcontext/core/database.py,sha256=ZLOHXv46hVxWiPYQala0Co7_Z8vqj5juaenudwq6DTU,14893
-codegraphcontext/core/database_embedded_kuzu.py,sha256=85J43enxfPgEAR9lu2HflaD-Pmfcx4Mc5vCka_Vho5o,82482
+codegraphcontext/core/database_embedded_kuzu.py,sha256=0MgfAN-3mH8saXqUysE42Kz30HTmyWGCOI3LwyGF9ww,82566
 codegraphcontext/core/database_falkordb.py,sha256=8TSFfgKoaNdTzSx7P4qXMMs2kTNBzrcW5tZxR8JV4bY,35834
 codegraphcontext/core/database_falkordb_remote.py,sha256=HdkcmwgUxPy1bwiFqqcU8yMQYib7B3JarYQ1LlTwfJ8,7957
 codegraphcontext/core/database_kuzu.py,sha256=5I31dGm7wRo3YjIWeWGRVcX1eYRXYc7fPWnT7zHFjf0,1123
@@ -39,7 +39,7 @@ codegraphcontext/core/simulator.py,sha256=qfjR5_EFd8elZWUZE92mi6F3mzjpBTfdnZMQr1
 codegraphcontext/core/watcher.py,sha256=aF96BdTQ8ye8L7-wmDC6LP2LMgUT47TOGSuCcNDniLM,20208
 codegraphcontext/tools/__init__.py,sha256=iqQPEkDlGXO7rAaLNQrS_ZAbLSklBSK-OowpARq0mig,41
 codegraphcontext/tools/advanced_language_query_tool.py,sha256=8pRVMg-Tbp3JrbN31McyTbum91gJPlrjHFCFVJ78coA,4169
-codegraphcontext/tools/code_finder.py,sha256=N67zRAfEswvDg_Bw7dVqv8yNS_VjoDvGNPPrJXPfRAg,93126
+codegraphcontext/tools/code_finder.py,sha256=dSd-k3z4QTyLrSjfHbx8bdmPn5e9tovoB7XXYW9wq2w,93116
 codegraphcontext/tools/graph_builder.py,sha256=NVbdAwH6mCLop167EFs3qctSw1W_FeFzC1WqAGiR_6I,27558
 codegraphcontext/tools/package_resolver.py,sha256=j6s4H5VnourUdJ-CkA3kCOc-Vdewnjc-PNDshAPCiaU,7802
 codegraphcontext/tools/report_generator.py,sha256=3tH83_24nm-pWcY_oXUeLB2jYtGGZmkiBb_oyuhS4WM,16114
@@ -49,12 +49,12 @@ codegraphcontext/tools/system.py,sha256=RCUraHQOT-M146CwLM3W1GcBHsAvuans1puL9SPa
 codegraphcontext/tools/tree_sitter_parser.py,sha256=xChDPOVhyHwsgwXrlYWy1iuIU1kdL6xxTNIqhgm1GbM,3669
 codegraphcontext/tools/type_utils.py,sha256=ZCJ9b1BwvL7LKl8Duhx-5uwX3Gemp5EGqLMso7zRY3E,472
 codegraphcontext/tools/datasources/__init__.py,sha256=EDY0_s7DJPRzJhfmYUz3Pxv0b6UIXP-l9KMp3xgg-WU,132
-codegraphcontext/tools/datasources/cassandra_ingester.py,sha256=sgbskSkvE98qtOprgzkbVSEIasZWe4WXOzaCiRR2c_Q,3060
-codegraphcontext/tools/datasources/mysql_ingester.py,sha256=uWstOv7mOEws1pmT8uAsEBkoOGM1FXOWt_2VCE-tZeg,3991
+codegraphcontext/tools/datasources/cassandra_ingester.py,sha256=06vvjslLyAwlYhLS5Wp55WY_6r6nFgh7py9dqfGuFT8,3697
+codegraphcontext/tools/datasources/mysql_ingester.py,sha256=JmGLrgMpz7HUUNpM1Np1xPXp9Gnjj8119AAP2Td6qKM,4767
 codegraphcontext/tools/datasources/redis_ingester.py,sha256=mVUKYmr_v6g7wYaavmQscEHGi_CPZrxYLjfkldc6cWE,3788
 codegraphcontext/tools/handlers/analysis_handlers.py,sha256=jPow6EEwUEQd3H7XfnU7no9GnZ80sY1E6KQyKv5sl_0,14186
 codegraphcontext/tools/handlers/indexing_handlers.py,sha256=GNpIR_4vY1DawOGUnU0PY4m_9VSUkWV7eh-J9eY5RIg,8031
-codegraphcontext/tools/handlers/management_handlers.py,sha256=19-fCuMuY5oHXQ9O4F1qG4ZsKKsGpSGbxxA1gH4AE-g,17419
+codegraphcontext/tools/handlers/management_handlers.py,sha256=5DyBLCR-a58S_qxki0naiUjQs096us1luWQ342jLpWI,17681
 codegraphcontext/tools/handlers/query_handlers.py,sha256=mqI7pfuSRc92ChAS5IGtrkPyhpPeh-dg-ewVnysx5nw,4643
 codegraphcontext/tools/handlers/watcher_handlers.py,sha256=po0NP3WnUqJAiDyZW9pz2g2V-itnazI10cXQJuc1UZ8,3809
 codegraphcontext/tools/indexing/__init__.py,sha256=exCNeB4UYhKhNSoEBNta_EZ51Kdze4iK4e3oWH8B4X8,126
@@ -128,14 +128,15 @@ codegraphcontext/utils/cypher_readonly.py,sha256=RyFBlAbQsNZtFdCN4jzf_WMNnzLIt2O
 codegraphcontext/utils/debug_log.py,sha256=eFKQmaB4iTGzcdytfwZszhcMJCK6jIPxPXKsJOncl4A,3023
 codegraphcontext/utils/gcf_encoder.py,sha256=H6G66BCqbOZpyM_4JOFne5F3YrZRA8fiMnT4S_gRCk8,1806
 codegraphcontext/utils/git_utils.py,sha256=D7ve2gpZaEHk4y6K4ga-o2ka89DVFX1acafD31YAyJM,1383
+codegraphcontext/utils/graph_shapes.py,sha256=1KkctKUh5OjMwa2hf1tDHx6OAbLMElQnrG-ISdvYfzI,4967
 codegraphcontext/utils/path_ignore.py,sha256=xaYCSq6nzUVX_mEdn3yrmwM--v7orJImga2XAQeiGB0,2168
 codegraphcontext/utils/path_sandbox.py,sha256=AemD1DHVMA0lj9BpmRkKwJB2OaE0SewggmJnyi0dr04,2784
 codegraphcontext/utils/repo_path.py,sha256=BxS3y6RV_WaZhg_WxgJygS4SnQa-Ryth2fsicfnYorY,1121
 codegraphcontext/utils/secret_scanner.py,sha256=Ml6hfiVN8gP_3W_CJWhBQ728HYv2UbmhDaM03SYbyEo,6384
 codegraphcontext/utils/tool_limits.py,sha256=3d-QnlzxBNocz58VKNhdsta7ZpWThs1AX46_gYXl6pQ,2751
 codegraphcontext/utils/tree_sitter_manager.py,sha256=vbbae9T69jUbMUphuBj1bnsT0HQJp5vYxzYFKZqV2HU,14496
-codegraphcontext/utils/visualize_graph.py,sha256=me35VuizqLyveT86XdgavrgnB2B4lG7WqFyiMr5ea1w,14644
-codegraphcontext/viz/server.py,sha256=l2hM6phhYeMn0vAmMz7wtRGdj7LMkg2BsNMOvS1RUfg,31833
+codegraphcontext/utils/visualize_graph.py,sha256=_KO8oCLooBccJHT99kZbYjwODobuEaGQbR0Rrb7NimQ,14951
+codegraphcontext/viz/server.py,sha256=MmbQ99nhTaKF4wsW8mPz_bUyTt40X9pYyIw3zp9cRJ0,32709
 codegraphcontext/viz/dist/cgcIcon.png,sha256=lik7hnqvkqLc5uo9w9Q_YJXtRx7cWPrXqSLttGtW1sg,58703
 codegraphcontext/viz/dist/favicon.ico,sha256=AjhUxD_Eslt5XuSVHIAZ494Fk__rb5GLXR8qm0elfP4,1870
 codegraphcontext/viz/dist/index.html,sha256=uEaFo3uHWD2KojFiyfWRJoS1_t6zrllOnf_siaB0I5U,1946
@@ -174,9 +175,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.6.8.dist-info/licenses/LICENSE,sha256=rh8M-bJpQYJnw2vtRVgt0t7piMZXh5QzaKeNEI0vqqA,1061
-codegraphcontext-0.6.8.dist-info/METADATA,sha256=Xo-Kwgpw1NiWuCNQPJCuO9tB9x4LLo26AC34fhPs6Zs,33788
-codegraphcontext-0.6.8.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-codegraphcontext-0.6.8.dist-info/entry_points.txt,sha256=LCxWCWMshdvYGoHBPuQZ8C-e4CiNSHCLXofrNSGHkoE,103
-codegraphcontext-0.6.8.dist-info/top_level.txt,sha256=CBgc6LAPZIO5FS0nSYYkylDifHsZTIqw3Gf5UwDxeGI,17
-codegraphcontext-0.6.8.dist-info/RECORD,,
+codegraphcontext-0.6.9.dist-info/licenses/LICENSE,sha256=rh8M-bJpQYJnw2vtRVgt0t7piMZXh5QzaKeNEI0vqqA,1061
+codegraphcontext-0.6.9.dist-info/METADATA,sha256=OFpyhssoYQhKZN-n3ScY3PSZdinMOQa7WWU5w8U_QNc,33788
+codegraphcontext-0.6.9.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+codegraphcontext-0.6.9.dist-info/entry_points.txt,sha256=LCxWCWMshdvYGoHBPuQZ8C-e4CiNSHCLXofrNSGHkoE,103
+codegraphcontext-0.6.9.dist-info/top_level.txt,sha256=CBgc6LAPZIO5FS0nSYYkylDifHsZTIqw3Gf5UwDxeGI,17
+codegraphcontext-0.6.9.dist-info/RECORD,,