codegraphcontext 0.6.8__tar.gz → 0.6.10__tar.gz

{codegraphcontext-0.6.8/src/codegraphcontext.egg-info → codegraphcontext-0.6.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphcontext
-Version: 0.6.8
+Version: 0.6.10
 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
@@ -873,6 +873,14 @@ Once the server is running, you can interact with it through your AI assistant u
 
 ---
 
+## Troubleshooting
+
+Hitting a lock error, a "never finishes indexing" loop, or a silent feature?
+See [docs/TROUBLESHOOTING.md](docs/TROUBLESHOOTING.md) — every entry maps a
+real reported issue to its fix or workaround.
+
+---
+
 ## Contributing
 
 Contributions are welcome! 🎉  

{codegraphcontext-0.6.8 → codegraphcontext-0.6.10}/README.md

@@ -774,6 +774,14 @@ Once the server is running, you can interact with it through your AI assistant u
 
 ---
 
+## Troubleshooting
+
+Hitting a lock error, a "never finishes indexing" loop, or a silent feature?
+See [docs/TROUBLESHOOTING.md](docs/TROUBLESHOOTING.md) — every entry maps a
+real reported issue to its fix or workaround.
+
+---
+
 ## Contributing
 
 Contributions are welcome! 🎉  

{codegraphcontext-0.6.8 → codegraphcontext-0.6.10}/pyproject.toml

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

{codegraphcontext-0.6.8 → codegraphcontext-0.6.10}/src/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
@@ -334,6 +342,21 @@ def index_helper(path: str, context: Optional[str] = None, no_progress: bool = F
         db_manager.close_driver()
         raise typer.Exit(code=1)
 
+    # Register the repo in its named context BEFORE the already-indexed skip
+    # guard below: the early return used to sit above this call, so a graph
+    # populated by any path that skipped registration (MCP add_code_to_graph,
+    # an interrupted run) could never reconcile config.yaml through the normal
+    # command — 'cgc context list' showed "Repos Linked: 0" forever (#1317).
+    # Registration is idempotent, so running it on every invocation is safe.
+    # The resolved context name is used so a *default* named context registers
+    # too, not only an explicit --context flag.
+    if ctx.mode == "named":
+        register_context_name = context or getattr(ctx, "context_name", None)
+        if register_context_name:
+            if not register_repo_in_context(register_context_name, str(path_obj), auto_create=False):
+                db_manager.close_driver()
+                raise typer.Exit(code=1)
+
     indexed_repos = code_finder.list_indexed_repositories()
     repo_exists = any_repo_matches_path(indexed_repos, path_obj)
 
@@ -392,11 +415,6 @@ def index_helper(path: str, context: Optional[str] = None, no_progress: bool = F
         except Exception as e:
             console.print(f"[yellow]Warning: Could not check file count: {e}. Proceeding with indexing...[/yellow]")
 
-    if context and ctx.mode == "named":
-        if not register_repo_in_context(context, str(path_obj), auto_create=False):
-            db_manager.close_driver()
-            raise typer.Exit(code=1)
-
     console.print(f"Starting indexing for: {path_obj}")
 
     try:
@@ -657,44 +675,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 +696,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-0.6.8 → codegraphcontext-0.6.10}/src/codegraphcontext/cli/main.py

@@ -711,6 +711,7 @@ def bundle_export(
     no_stats: bool = typer.Option(False, "--no-stats", help="Skip statistics generation"),
     sign_key: Optional[str] = typer.Option(None, "--sign-key", envvar="CGC_BUNDLE_SIGN_KEY", help="HMAC signing key (or set CGC_BUNDLE_SIGN_KEY)"),
     encrypt_password: Optional[str] = typer.Option(None, "--encrypt-password", envvar="CGC_BUNDLE_PASSWORD", help="Encrypt bundle with this password (or set CGC_BUNDLE_PASSWORD)", hide_input=True),
+    exclude_labels: Optional[str] = typer.Option(None, "--exclude-labels", help="Comma-separated node labels to leave out of the bundle, with their edges (e.g. DbTable,ExternalClass) (#1323)"),
     context: Optional[str] = typer.Option(None, "--context", "-c", help="Specific context to use"),
 ):
     """
@@ -760,6 +761,14 @@ def bundle_export(
             include_stats=not no_stats,
             sign_key=sign_key,
             encrypt_password=encrypt_password,
+            # bundle_export is also called programmatically (the golden
+            # harness does), where unpassed Typer options arrive as OptionInfo
+            # objects rather than their defaults — same trap the CLI meta-test
+            # documents for other commands.
+            exclude_labels=[
+                l for l in (exclude_labels if isinstance(exclude_labels, str) else "").split(",")
+                if l.strip()
+            ],
         )
         
         if success:
@@ -1137,6 +1146,7 @@ def export_shortcut(
     no_stats: bool = typer.Option(False, "--no-stats", help="Skip generating statistics in the bundle"),
     sign_key: Optional[str] = typer.Option(None, "--sign-key", envvar="CGC_BUNDLE_SIGN_KEY", help="HMAC signing key (or set CGC_BUNDLE_SIGN_KEY)"),
     encrypt_password: Optional[str] = typer.Option(None, "--encrypt-password", envvar="CGC_BUNDLE_PASSWORD", help="Encrypt bundle with this password (or set CGC_BUNDLE_PASSWORD)", hide_input=True),
+    exclude_labels: Optional[str] = typer.Option(None, "--exclude-labels", help="Comma-separated node labels to leave out of the bundle, with their edges (e.g. DbTable,ExternalClass) (#1323)"),
     context: Optional[str] = typer.Option(None, "--context", "-c", help="Specific context to use"),
 ):
     """Shortcut for 'cgc bundle export'"""
@@ -1146,6 +1156,7 @@ def export_shortcut(
         no_stats=no_stats,
         sign_key=sign_key,
         encrypt_password=encrypt_password,
+        exclude_labels=exclude_labels,
         context=context,
     )
 
@@ -2546,16 +2557,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 +2583,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 +3647,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 +3664,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 +3687,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 +3705,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-0.6.8 → codegraphcontext-0.6.10}/src/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-0.6.8 → codegraphcontext-0.6.10}/src/codegraphcontext/core/cgc_bundle.py

@@ -199,6 +199,7 @@ class CGCBundle:
         include_stats: bool = True,
         sign_key: Optional[str] = None,
         encrypt_password: Optional[str] = None,
+        exclude_labels: Optional[List[str]] = None,
     ) -> Tuple[bool, str]:
         """
         Export the current graph (or a specific repository) to a .cgc bundle.
@@ -225,6 +226,12 @@ class CGCBundle:
                 # Step 1: Extract metadata base
                 info_logger("Extracting metadata...")
                 metadata = self._extract_metadata(repo_path)
+                if exclude_labels:
+                    # Recorded for transparency: a consumer can tell a bundle
+                    # was exported without these node types (#1323).
+                    metadata["excluded_labels"] = sorted(
+                        {l.strip() for l in exclude_labels if l.strip()}
+                    )
                 
                 # Step 2: Extract schema
                 info_logger("Extracting schema...")
@@ -234,7 +241,7 @@ class CGCBundle:
                 
                 # Step 3: Extract nodes
                 info_logger("Extracting nodes...")
-                node_count = self._extract_nodes(temp_path / "nodes.jsonl", repo_path)
+                node_count = self._extract_nodes(temp_path / "nodes.jsonl", repo_path, exclude_labels=exclude_labels)
                 if node_count == 0:
                     return False, (
                         "No nodes to export. Index the repository first or verify "
@@ -244,6 +251,7 @@ class CGCBundle:
                 # Step 4: Extract edges
                 info_logger("Extracting edges...")
                 edge_count = self._extract_edges(temp_path / "edges.jsonl", repo_path)
+                # (edge filtering uses the id set _extract_nodes recorded)
                 
                 # Step 5: Generate statistics and assemble standardized metadata
                 if include_stats:
@@ -667,10 +675,19 @@ class CGCBundle:
             """,
         ]
     
-    def _extract_nodes(self, output_file: Path, repo_path: Optional[Path]) -> int:
-        """Extract all nodes to JSONL format."""
+    def _extract_nodes(self, output_file: Path, repo_path: Optional[Path], exclude_labels: Optional[List[str]] = None) -> int:
+        """Extract all nodes to JSONL format.
+
+        ``exclude_labels`` drops nodes carrying any of the given labels
+        (#1323 — e.g. DbTable/ExternalClass datasource metadata that path
+        filters can never reach). Their ids are recorded so
+        ``_extract_edges`` drops the touching edges too, keeping the bundle
+        free of dangling endpoints.
+        """
         count = 0
         seen_nodes = set()
+        excluded = {l.strip() for l in (exclude_labels or []) if l.strip()}
+        self._excluded_node_ids = set()
         
         with self.db_manager.get_driver(self._active_graph).session() as session:
             if repo_path:
@@ -691,6 +708,12 @@ class CGCBundle:
                         if node_key in seen_nodes:
                             continue
                         seen_nodes.add(node_key)
+
+                        if excluded and any(l in excluded for l in labels):
+                            self._excluded_node_ids.add(
+                                self._stable_id_key(self._export_id_of(node, node_dict))
+                            )
+                            continue
                     
                         # Clean up absolute path prefix to keep it relative
                         if repo_path:
@@ -718,6 +741,24 @@ class CGCBundle:
         
         return count
     
+    @staticmethod
+    def _stable_id_key(node_id) -> str:
+        """A hashable, backend-agnostic key for a node id (dict for Kùzu,
+        string for Neo4j/FalkorDB)."""
+        if isinstance(node_id, dict):
+            return json.dumps(node_id, sort_keys=True, default=str)
+        return str(node_id)
+
+    @staticmethod
+    def _export_id_of(node, node_dict):
+        if '_id' in node_dict:
+            return node_dict['_id']
+        if hasattr(node, 'element_id'):
+            return node.element_id
+        if hasattr(node, 'id'):
+            return str(node.id)
+        return None
+
     def _extract_edges(self, output_file: Path, repo_path: Optional[Path]) -> int:
         """Extract all relationships to JSONL format."""
         count = 0
@@ -779,6 +820,16 @@ class CGCBundle:
                             else:
                                 to_id = str(id(target))
 
+                        # Drop edges touching a label-excluded node (#1323):
+                        # nodes.jsonl no longer carries the endpoint, and a
+                        # dangling reference is an import failure waiting.
+                        excluded_ids = getattr(self, "_excluded_node_ids", None)
+                        if excluded_ids and (
+                            self._stable_id_key(from_id) in excluded_ids
+                            or self._stable_id_key(to_id) in excluded_ids
+                        ):
+                            continue
+
                         # Clean up absolute path prefix inside edge properties
                         if repo_path:
                             repo_str = repo_path.resolve().as_posix()

{codegraphcontext-0.6.8 → codegraphcontext-0.6.10}/src/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-0.6.8 → codegraphcontext-0.6.10}/src/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-0.6.8 → codegraphcontext-0.6.10}/src/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",