codegraphcontext 0.4.11__py3-none-any.whl → 0.4.12__py3-none-any.whl

codegraphcontext/cli/config_manager.py

@@ -62,6 +62,8 @@ DEFAULT_CONFIG = {
     "ENABLE_VECTOR_RESOLVE": "false",
     "CGC_EMBEDDING_MODEL": "local",
     "CGC_EMBEDDING_BATCH_SIZE": "256",
+    # Default fuzzy matching behavior for `cgc find name` (overridable per-command with --fuzzy/--no-fuzzy)
+    "FUZZY_SEARCH": "true",
 }
 
 # Configuration key descriptions
@@ -123,6 +125,10 @@ CONFIG_DESCRIPTIONS = {
         "Number of function texts to embed per batch when ENABLE_VECTOR_RESOLVE=true. "
         "Larger values are faster but use more RAM. Default: 256. Reduce to 64 if you hit memory errors."
     ),
+    "FUZZY_SEARCH": (
+        "Enable fuzzy matching by default for `cgc find name` (true|false). "
+        "Per-invocation overrides are available via --fuzzy / --no-fuzzy."
+    ),
 }
 
 # Valid values for each config key
@@ -143,6 +149,7 @@ CONFIG_VALIDATORS = {
     "ENABLE_INHERIT_RESOLVE": ["true", "false"],
     "ENABLE_VECTOR_RESOLVE": ["true", "false"],
     "CGC_EMBEDDING_MODEL": ["local", "openai"],
+    "FUZZY_SEARCH": ["true", "false"],
 }
 DEFAULT_CGCIGNORE_PATTERNS = """\
 # Default .cgcignore patterns

codegraphcontext/cli/main.py

@@ -285,7 +285,7 @@ def context_default(
 # CREDENTIALS LOADING PRECEDENCE
 # ============================================================================
 
-def _load_credentials():
+def _load_credentials(cli_context_flag: Optional[str] = None):
     """
     Loads configuration and credentials from various sources into environment variables.
     Uses per-variable precedence - each variable is loaded from the highest priority source.
@@ -336,7 +336,7 @@ def _load_credentials():
     mcp_file_path = Path.cwd() / "mcp.json"
     if mcp_file_path.exists():
         try:
-            with open(mcp_file_path, "r") as f:
+            with open(mcp_file_path, "r", encoding="utf-8", errors="replace") as f:
                 mcp_config = json.load(f)
             server_env = mcp_config.get("mcpServers", {}).get("CodeGraphContext", {}).get("env", {})
             if isinstance(server_env, dict):
@@ -355,7 +355,8 @@ def _load_credentials():
     global_env_path = Path.home() / ".codegraphcontext" / ".env"
     if global_env_path.exists():
         try:
-            _append_source(str(global_env_path), dotenv_values(str(global_env_path)))
+            with open(global_env_path, "r", encoding="utf-8", errors="replace") as f:
+                _append_source(str(global_env_path), dotenv_values(stream=f))
         except Exception as e:
             console.print(f"[yellow]Warning: Could not load global .env: {e}[/yellow]")
     
@@ -363,7 +364,8 @@ def _load_credentials():
     try:
         dotenv_path = find_dotenv(usecwd=True, raise_error_if_not_found=False)
         if dotenv_path:
-            _append_source(str(dotenv_path), dotenv_values(dotenv_path))
+            with open(dotenv_path, "r", encoding="utf-8", errors="replace") as f:
+                _append_source(str(dotenv_path), dotenv_values(stream=f))
     except Exception as e:
         console.print(f"[yellow]Warning: Could not load .env from current directory: {e}[/yellow]")
 
@@ -371,8 +373,9 @@ def _load_credentials():
     try:
         local_cgc_env = codegraphcontext_dotenv_at_cwd(Path.cwd())
         if local_cgc_env and local_cgc_env.resolve() != global_env_path.resolve():
-            config_sources.append(dotenv_values(str(local_cgc_env)))
-            config_source_names.append(str(local_cgc_env))
+            with open(local_cgc_env, "r", encoding="utf-8", errors="replace") as f:
+                vals = dotenv_values(stream=f)
+                _append_source(str(local_cgc_env), vals)
     except Exception as e:
         console.print(
             f"[yellow]Warning: Could not load .codegraphcontext/.env at cwd: {e}[/yellow]"
@@ -418,31 +421,62 @@ def _load_credentials():
         )
     
     
-    # Show which database is actually being used.
-    # When CGC_RUNTIME_DB_TYPE or DEFAULT_DATABASE is set, trust it. Otherwise
-    # call get_database_manager() so the banner matches factory fallbacks.
-    runtime_db = os.environ.get("CGC_RUNTIME_DB_TYPE")
-    database_type = os.environ.get("DATABASE_TYPE")
-    default_database = os.environ.get("DEFAULT_DATABASE")
+    # Detect the context to see if it specifies a custom database
+    if cli_context_flag is None:
+        import sys
+        for i, arg in enumerate(sys.argv):
+            if arg in ("--context", "-c"):
+                if i + 1 < len(sys.argv):
+                    cli_context_flag = sys.argv[i + 1]
+                    break
+            elif arg.startswith("--context="):
+                cli_context_flag = arg.split("=", 1)[1]
+                break
+
+    from codegraphcontext.cli.config_manager import resolve_context
+    ctx = None
+    try:
+        ctx = resolve_context(cli_context_flag)
+    except Exception:
+        pass
 
-    explicit_db = runtime_db or database_type or default_database
+    # Determine if there is a runtime database override.
+    runtime_db = os.environ.get("CGC_RUNTIME_DB_TYPE")
+    has_runtime_override = (
+        runtime_db is not None
+        or "DATABASE_TYPE" in runtime_env
+        or "DEFAULT_DATABASE" in runtime_env
+    )
 
+    # If there is no runtime override, but the context defines a database,
+    # set DEFAULT_DATABASE to the context database to ensure that's what gets initialized.
+    if not has_runtime_override and ctx and ctx.mode != "global" and ctx.database:
+        os.environ["DEFAULT_DATABASE"] = ctx.database
+
+    # Now select the database based on precedence:
+    # 1. CGC_RUNTIME_DB_TYPE
+    # 2. DATABASE_TYPE or DEFAULT_DATABASE from runtime environment (shell variables)
+    # 3. Context database
+    # 4. DATABASE_TYPE or DEFAULT_DATABASE from merged config files (.env files)
+    # 5. Auto-detect fallback
     if runtime_db:
+        default_db = runtime_db.lower()
         db_source = "runtime-env (CGC_RUNTIME_DB_TYPE)"
     elif "DATABASE_TYPE" in runtime_env:
+        default_db = runtime_env["DATABASE_TYPE"].lower()
         db_source = "environment (DATABASE_TYPE)"
     elif "DEFAULT_DATABASE" in runtime_env:
+        default_db = runtime_env["DEFAULT_DATABASE"].lower()
         db_source = "environment (DEFAULT_DATABASE)"
-    elif database_type and "DATABASE_TYPE" in key_source_map:
+    elif not has_runtime_override and ctx and ctx.mode != "global" and ctx.database:
+        default_db = ctx.database.lower()
+        db_source = f"context ({ctx.context_name or 'resolved'})"
+    elif os.environ.get("DATABASE_TYPE") and "DATABASE_TYPE" in key_source_map:
+        default_db = os.environ["DATABASE_TYPE"].lower()
         db_source = key_source_map["DATABASE_TYPE"]
-    elif default_database and "DEFAULT_DATABASE" in key_source_map:
+    elif os.environ.get("DEFAULT_DATABASE") and "DEFAULT_DATABASE" in key_source_map:
+        default_db = os.environ["DEFAULT_DATABASE"].lower()
         db_source = key_source_map["DEFAULT_DATABASE"]
-    else:
-        db_source = "auto-detect"
-    explicit_db = runtime_db or os.environ.get("DEFAULT_DATABASE")
-
-    if explicit_db:
-        default_db = explicit_db.lower()
     else:
         # No explicit choice — ask the factory which backend it will use
         try:
@@ -455,6 +489,7 @@ def _load_credentials():
             default_db = "falkordb" if _is_falkordb_available() else "kuzudb"
         db_source = "auto-detect"
 
+    # Print selection banner
     if default_db == "neo4j":
         has_neo4j_creds = all([
             os.environ.get("NEO4J_URI"),
@@ -473,20 +508,14 @@ def _load_credentials():
         console.print(f"[cyan]Using database: falkordb (source: {db_source})[/cyan]")
     elif default_db == "kuzudb":
         console.print(f"[cyan]Using database: kuzudb (source: {db_source})[/cyan]")
+    elif default_db == "ladybugdb":
+        console.print(f"[cyan]Using database: ladybugdb (source: {db_source})[/cyan]")
     elif default_db == "falkordb-remote":
         host = os.environ.get("FALKORDB_HOST")
         if host:
             console.print(f"[cyan]Using database: falkordb-remote (source: {db_source}, host: {host})[/cyan]")
         else:
             console.print("[yellow]⚠ DATABASE_TYPE=falkordb-remote but FALKORDB_HOST not set.[/yellow]")
-    elif default_db == "falkordb":
-        if os.environ.get("FALKORDB_HOST"):
-            console.print(f"[cyan]Using database: falkordb-remote (source: {db_source}, host: {os.environ.get('FALKORDB_HOST')})[/cyan]")
-        else:
-            console.print(f"[cyan]Using database: falkordb (source: {db_source})[/cyan]")
-            console.print(
-                "[yellow]⚠ DEFAULT_DATABASE=falkordb-remote but FALKORDB_HOST not set.[/yellow]"
-            )
     else:
         console.print(f"[cyan]Using database: {default_db} (source: {db_source})[/cyan]")
 
@@ -543,7 +572,7 @@ def config_reset():
         console.print("[yellow]Reset cancelled[/yellow]")
 
 @config_app.command("db")
-def config_db(backend: str = typer.Argument(..., help="Database backend: 'neo4j', 'falkordb', 'falkordb-remote', or 'kuzudb'")):
+def config_db(backend: str = typer.Argument(..., help="Database backend: 'neo4j', 'falkordb', 'falkordb-remote', 'kuzudb', or 'ladybugdb'")):
     """
     Quickly switch the default database backend.
     
@@ -1388,17 +1417,22 @@ app.add_typer(find_app, name="find")
 @find_app.command("name")
 def find_by_name(
     ctx: typer.Context,
-    name: str = typer.Argument(..., help="Exact name to search for"),
+    name: str = typer.Argument(..., help="Name to search for"),
     type: Optional[str] = typer.Option(None, "--type", "-t", help="Filter by type (function, class, file, module)"),
+    fuzzy: Optional[bool] = typer.Option(None, "--fuzzy/--no-fuzzy", help="Enable/disable fuzzy matching for this command. Overrides the FUZZY_SEARCH config value (default: true)."),
     visual: bool = typer.Option(False, "--visual", "--viz", "-V", help="Show results as interactive graph visualization"),
     context: Optional[str] = typer.Option(None, "--context", "-c", help="Specific context to use"),
 ):
     """
-    Find code elements by exact name.
-    
+    Find code elements by name.
+
+    Fuzzy matching is enabled by default (configurable via the FUZZY_SEARCH
+    config key, or per-invocation with --fuzzy / --no-fuzzy).
+
     Examples:
         cgc find name MyClass
         cgc find name calculate --type function
+        cgc find name MyClass --no-fuzzy
         cgc find name MyClass --visual
     """
     _load_credentials()
@@ -1406,14 +1440,22 @@ def find_by_name(
     if not all(services[:3]):
         return
     db_manager, graph_builder, code_finder = services[:3]
-    
+
+    # Resolve effective fuzzy setting: CLI flag wins, else config, else true.
+    if fuzzy is None:
+        from codegraphcontext.cli.config_manager import load_config
+        cfg_value = load_config().get("FUZZY_SEARCH", "true")
+        fuzzy_search = str(cfg_value).strip().lower() == "true"
+    else:
+        fuzzy_search = fuzzy
+
     try:
         results = []
-        
+
         # Search based on type filter
         if type is None or type.lower() == 'all':
-            funcs = code_finder.find_by_function_name(name, fuzzy_search=False)
-            classes = code_finder.find_by_class_name(name, fuzzy_search=False)
+            funcs = code_finder.find_by_function_name(name, fuzzy_search=fuzzy_search)
+            classes = code_finder.find_by_class_name(name, fuzzy_search=fuzzy_search)
             variables = code_finder.find_by_variable_name(name)
             modules = code_finder.find_by_module_name(name)
             imports = code_finder.find_imports(name)
@@ -1445,11 +1487,11 @@ def find_by_name(
                         results.append(row)
         
         elif type.lower() == 'function':
-            results = code_finder.find_by_function_name(name, fuzzy_search=False)
+            results = code_finder.find_by_function_name(name, fuzzy_search=fuzzy_search)
             for r in results: r['type'] = 'Function'
-            
+
         elif type.lower() == 'class':
-            results = code_finder.find_by_class_name(name, fuzzy_search=False)
+            results = code_finder.find_by_class_name(name, fuzzy_search=fuzzy_search)
             for r in results: r['type'] = 'Class'
             
         elif type.lower() == 'variable':
@@ -2226,10 +2268,10 @@ def analyze_inheritance_tree(
 
 @analyze_app.command("complexity")
 def analyze_complexity(
-    path: Optional[str] = typer.Argument(None, help="Specific function name to analyze"),
+    path: Optional[str] = typer.Argument(None, help="Function name or file path to analyze"),
     threshold: int = typer.Option(10, "--threshold", "-t", help="Complexity threshold for warnings"),
     limit: int = typer.Option(20, "--limit", "-l", help="Maximum results to show"),
-    file: Optional[str] = typer.Option(None, "--file", "-f", help="Specific file path (only used when function name is provided)"),
+    file: Optional[str] = typer.Option(None, "--file", "-f", help="Specific file path to scope analysis"),
     context: Optional[str] = typer.Option(None, "--context", "-c", help="Specific context to use"),
 ):
     """
@@ -2240,16 +2282,55 @@ def analyze_complexity(
         cgc analyze complexity --threshold 15     # Functions over threshold
         cgc analyze complexity my_function        # Specific function
         cgc analyze complexity my_function -f file.py # Specific function in file
+        cgc analyze complexity src/main.py        # Most complex functions in file
+        cgc analyze complexity main.py            # Most complex functions in file
+        cgc analyze complexity --file src/main.py # Alternative file syntax
     """
     _load_credentials()
     services = _initialize_services(context)
     if not all(services[:3]):
         return
     db_manager, graph_builder, code_finder = services[:3]
-    
+
+    _FILE_EXTENSIONS = ('.py', '.js', '.ts', '.jsx', '.tsx', '.go', '.rs', '.rb',
+                        '.java', '.cpp', '.c', '.cs', '.swift', '.kt', '.scala',
+                        '.php', '.lua', '.zig', '.ex', '.exs', '.r', '.m', '.sh')
+
+    def _is_file_path(value: str) -> bool:
+        if '/' in value or '\\' in value:
+            return True
+        return any(value.endswith(ext) for ext in _FILE_EXTENSIONS)
+
+    def _render_complexity_table(results, title):
+        if not results:
+            console.print("[yellow]No complexity data available for this file[/yellow]")
+            return
+        table = Table(show_header=True, header_style="bold magenta", box=box.ROUNDED)
+        table.add_column("Function", style="cyan")
+        table.add_column("Complexity", style="yellow", justify="right")
+        table.add_column("Location", style="dim", overflow="fold")
+        for func in results:
+            complexity = func.get('complexity', 0)
+            color = "red" if complexity > threshold else "yellow" if complexity > threshold/2 else "green"
+            fpath = func.get('path', '')
+            line_str = str(func.get('line_number', ''))
+            location_str = f"{fpath}:{line_str}" if line_str else fpath
+            table.add_row(
+                func.get('function_name', ''),
+                f"[{color}]{complexity}[/{color}]",
+                location_str
+            )
+        console.print(f"\n[bold cyan]{title}[/bold cyan]")
+        console.print(table)
+        console.print(f"\n[dim]{len([f for f in results if f.get('complexity', 0) > threshold])} function(s) exceed threshold[/dim]")
+
     try:
-        if path:
-            # Specific function
+        if path and _is_file_path(path):
+            # File path provided as positional argument
+            results = code_finder.find_most_complex_functions_in_file(path, limit)
+            _render_complexity_table(results, f"Most Complex Functions in '{path}' (threshold: {threshold}):")
+        elif path:
+            # Specific function name
             result = code_finder.get_cyclomatic_complexity(path, file)
             if result:
                 console.print(f"\n[bold cyan]Complexity for '{path}':[/bold cyan]")
@@ -2258,35 +2339,14 @@ def analyze_complexity(
                 console.print(f"  Line: [dim]{result.get('line_number', '')}[/dim]")
             else:
                 console.print(f"[yellow]Function '{path}' not found or has no complexity data[/yellow]")
+        elif file:
+            # --file option without positional arg
+            results = code_finder.find_most_complex_functions_in_file(file, limit)
+            _render_complexity_table(results, f"Most Complex Functions in '{file}' (threshold: {threshold}):")
         else:
-            # Most complex functions
+            # Global - most complex functions
             results = code_finder.find_most_complex_functions(limit)
-            
-            if not results:
-                console.print("[yellow]No complexity data available[/yellow]")
-                return
-            
-            table = Table(show_header=True, header_style="bold magenta", box=box.ROUNDED)
-            table.add_column("Function", style="cyan")
-            table.add_column("Complexity", style="yellow", justify="right")
-            table.add_column("Location", style="dim", overflow="fold")
-            
-            for func in results:
-                complexity = func.get('complexity', 0)
-                color = "red" if complexity > threshold else "yellow" if complexity > threshold/2 else "green"
-                path = func.get('path', '')
-                line_str = str(func.get('line_number', ''))
-                location_str = f"{path}:{line_str}" if line_str else path
-
-                table.add_row(
-                    func.get('function_name', ''),
-                    f"[{color}]{complexity}[/{color}]",
-                    location_str
-                )
-            
-            console.print(f"\n[bold cyan]Most Complex Functions (threshold: {threshold}):[/bold cyan]")
-            console.print(table)
-            console.print(f"\n[dim]{len([f for f in results if f.get('complexity', 0) > threshold])} function(s) exceed threshold[/dim]")
+            _render_complexity_table(results, f"Most Complex Functions (threshold: {threshold}):")
     finally:
         db_manager.close_driver()
 

codegraphcontext/cli/registry_commands.py

@@ -238,11 +238,14 @@ def download_bundle(name: str, output_dir: Optional[str] = None, auto_load: bool
     
     # Determine output path
     bundle_filename = bundle.get('bundle_name', f"{name}.cgc")
+    is_base64 = download_url.endswith('.base64') or bundle_filename.endswith('.base64')
+    clean_filename = bundle_filename.replace('.base64', '')
+    
     if output_dir:
-        output_path = Path(output_dir) / bundle_filename
+        output_path = Path(output_dir) / clean_filename
         output_path.parent.mkdir(parents=True, exist_ok=True)
     else:
-        output_path = Path.cwd() / bundle_filename
+        output_path = Path.cwd() / clean_filename
     
     # Check if already exists
     if output_path.exists():
@@ -257,7 +260,7 @@ def download_bundle(name: str, output_dir: Optional[str] = None, auto_load: bool
     
     # Download with progress bar
     try:
-        console.print(f"[cyan]Downloading {bundle_filename}...[/cyan]")
+        console.print(f"[cyan]Downloading {clean_filename}...[/cyan]")
         console.print(f"[dim]From: {download_url}[/dim]")
         
         response = requests.get(download_url, stream=True, timeout=30)
@@ -272,11 +275,20 @@ def download_bundle(name: str, output_dir: Optional[str] = None, auto_load: bool
         ) as progress:
             task = progress.add_task(f"Downloading {bundle.get('size', 'unknown')}...", total=total_size)
             
-            with open(output_path, 'wb') as f:
-                for chunk in response.iter_content(chunk_size=8192):
-                    if chunk:
-                        f.write(chunk)
-                        progress.update(task, advance=len(chunk))
+            if is_base64:
+                # Read entire base64 response, decode it, and write it
+                base64_content = response.content.strip()
+                import base64
+                decoded_content = base64.b64decode(base64_content)
+                with open(output_path, 'wb') as f:
+                    f.write(decoded_content)
+                progress.update(task, completed=total_size)
+            else:
+                with open(output_path, 'wb') as f:
+                    for chunk in response.iter_content(chunk_size=8192):
+                        if chunk:
+                            f.write(chunk)
+                            progress.update(task, advance=len(chunk))
         
         console.print(f"[bold green]✓ Downloaded successfully: {output_path}[/bold green]")
         

codegraphcontext/core/__init__.py

@@ -26,6 +26,13 @@ def _is_kuzudb_available() -> bool:
     except ImportError:
         return False
 
+def _is_ladybugdb_available() -> bool:
+    """Check if LadybugDB is installed."""
+    try:
+        return importlib.util.find_spec("ladybug") is not None
+    except ImportError:
+        return False
+
 def _is_falkordb_available() -> bool:
     """Check if FalkorDB Lite is installed (Unix only)."""
     if platform.system() == "Windows":
@@ -127,8 +134,8 @@ def get_database_manager(db_path: Optional[str] = None) -> Union['DatabaseManage
             info_logger("Using Nornic DB (explicit)")
             return NornicDBManager()
         elif db_type == 'ladybugdb':
-            if not _is_kuzudb_available():
-                raise ValueError("Database set to 'ladybugdb' but LadybugDB core (kuzu) is not installed.\nRun 'pip install kuzu'")
+            if not _is_ladybugdb_available():
+                raise ValueError("Database set to 'ladybugdb' but LadybugDB is not installed.\nRun 'pip install ladybug'")
             from .database_ladybug import LadybugDBManager
             info_logger(f"Using LadybugDB (explicit) at {db_path or 'default path'}")
             return LadybugDBManager(db_path=db_path)

codegraphcontext/core/bundle_registry.py

@@ -16,10 +16,12 @@ def _github_headers() -> dict:
         headers["Authorization"] = f"token {token}"
     return headers
 
-GITHUB_ORG = "CodeGraphContext"
-GITHUB_REPO = "CodeGraphContext"
-REGISTRY_API_URL = f"https://api.github.com/repos/{GITHUB_ORG}/{GITHUB_REPO}/releases"
-MANIFEST_URL = f"https://github.com/{GITHUB_ORG}/{GITHUB_REPO}/releases/download/on-demand-bundles/manifest.json"
+def _get_manifest_url() -> str:
+    import os
+    hf_repo = os.environ.get("HF_REGISTRY_REPO") or "codegraphcontext/bundles"
+    return f"https://huggingface.co/datasets/{hf_repo}/raw/main/manifest.json"
+
+REGISTRY_API_URL = "https://api.github.com/repos/CodeGraphContext/CodeGraphContext/releases"
 
 class BundleRegistry:
     """
@@ -38,7 +40,7 @@ class BundleRegistry:
         
         # 1. Fetch on-demand bundles from manifest
         try:
-            response = requests.get(MANIFEST_URL, headers=_github_headers(), timeout=10)
+            response = requests.get(_get_manifest_url(), headers=_github_headers(), timeout=10)
             if response.status_code == 200:
                 manifest = response.json()
                 if manifest.get('bundles'):

codegraphcontext/core/cgc_bundle.py

@@ -28,7 +28,7 @@ from datetime import datetime, date
 import subprocess
 
 from codegraphcontext.utils.debug_log import debug_log, info_logger, error_logger, warning_logger
-from codegraphcontext.utils.git_utils import get_repo_commit_hash
+from codegraphcontext.utils.git_utils import get_repo_commit_hash, get_repo_branch_name
 
 
 class _BundleEncoder(json.JSONEncoder):
@@ -106,11 +106,9 @@ class CGCBundle:
             with tempfile.TemporaryDirectory() as temp_dir:
                 temp_path = Path(temp_dir)
                 
-                # Step 1: Extract metadata
+                # Step 1: Extract metadata base
                 info_logger("Extracting metadata...")
                 metadata = self._extract_metadata(repo_path)
-                with open(temp_path / "metadata.json", 'w') as f:
-                    json.dump(metadata, f, indent=2, cls=_BundleEncoder)
                 
                 # Step 2: Extract schema
                 info_logger("Extracting schema...")
@@ -126,12 +124,48 @@ class CGCBundle:
                 info_logger("Extracting edges...")
                 edge_count = self._extract_edges(temp_path / "edges.jsonl", repo_path)
                 
-                # Step 5: Generate statistics
+                # Step 5: Generate statistics and assemble standardized metadata
                 if include_stats:
                     info_logger("Generating statistics...")
                     stats = self._generate_stats(repo_path, node_count, edge_count)
                     with open(temp_path / "stats.json", 'w') as f:
                         json.dump(stats, f, indent=2, cls=_BundleEncoder)
+                else:
+                    stats = None
+
+                # Compile dynamic standardized metadata
+                try:
+                    from importlib.metadata import version as get_version
+                    py_version = get_version("codegraphcontext")
+                except Exception:
+                    py_version = "0.4.12"
+
+                metadata["format_version"] = "1.0.0"
+                metadata["generator"] = f"PYv{py_version}"
+                
+                # Timestamp format: YYYY-MM-DDTHH:MM:SSZ (UTC ISO String format)
+                # datetime.utcnow() was deprecated, using timezone-aware or simple UTC strftime
+                from datetime import timezone
+                metadata["exported_at"] = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+                # Build name
+                if metadata.get("repo") and "/" in metadata["repo"]:
+                    owner, repo_name = metadata["repo"].split("/", 1)
+                    branch = metadata.get("branch", "main")
+                    commit = metadata.get("commit", "latest")
+                    metadata["name"] = f"{owner}__{repo_name}__{branch}__{commit}.cgc"
+                else:
+                    foldername = metadata.get("repo", "unknown")
+                    metadata["name"] = f"{foldername}.cgc"
+
+                metadata["graph_metrics"] = {
+                    "total_nodes": node_count,
+                    "total_edges": edge_count
+                }
+
+                # Save final metadata.json
+                with open(temp_path / "metadata.json", 'w') as f:
+                    json.dump(metadata, f, indent=2, cls=_BundleEncoder)
                 
                 # Step 6: Create README
                 self._create_readme(temp_path / "README.md", metadata, stats if include_stats else None)
@@ -304,6 +338,9 @@ class CGCBundle:
                 commit = get_repo_commit_hash(repo_path)
                 if commit:
                     metadata["commit"] = commit[:8]
+                branch = get_repo_branch_name(repo_path)
+                if branch:
+                    metadata["branch"] = branch
 
                 try:
                     result = session.run("""

codegraphcontext/tools/code_finder.py

@@ -1357,6 +1357,23 @@ class CodeFinder:
             result = session.run(query, limit=limit, repo_path=repo_path)
             return result.data()
 
+    def find_most_complex_functions_in_file(self, file_path: str, limit: int = 20, repo_path: Optional[str] = None) -> List[Dict]:
+        """Find the most complex functions in a specific file."""
+        with self.driver.session() as session:
+            repo_filter = "AND f.path STARTS WITH $repo_path" if repo_path else ""
+            query = f"""
+                MATCH (f:Function)
+                WHERE f.cyclomatic_complexity IS NOT NULL
+                  AND (f.path ENDS WITH $file_path OR f.path = $file_path)
+                  {repo_filter}
+                RETURN f.name as function_name, f.path as path,
+                       f.cyclomatic_complexity as complexity, f.line_number as line_number
+                ORDER BY f.cyclomatic_complexity DESC
+                LIMIT $limit
+            """
+            result = session.run(query, file_path=file_path, limit=limit, repo_path=repo_path)
+            return result.data()
+
     def list_indexed_repositories(self) -> List[Dict]:
         """List all indexed repositories."""
         with self.driver.session() as session:

codegraphcontext/utils/git_utils.py

@@ -24,3 +24,16 @@ def get_repo_commit_hash(repo_path: Path) -> Optional[str]:
         return sha if sha else None
     except (subprocess.CalledProcessError, FileNotFoundError, OSError):
         return None
+
+
+def get_repo_branch_name(repo_path: Path) -> Optional[str]:
+    """Return the active git branch name for *repo_path*, or ``None``."""
+    try:
+        branch = subprocess.check_output(
+            ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+            cwd=repo_path,
+            stderr=subprocess.DEVNULL,
+        ).decode().strip()
+        return branch if branch else None
+    except (subprocess.CalledProcessError, FileNotFoundError, OSError):
+        return None

{codegraphcontext-0.4.11.dist-info → codegraphcontext-0.4.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphcontext
-Version: 0.4.11
+Version: 0.4.12
 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
@@ -168,7 +168,7 @@ A powerful **MCP server** and **CLI toolkit** that indexes local code into a gra
 ---
 
 ## Project Details
-- **Version:** 0.4.11
+- **Version:** 0.4.12
 - **Authors:** Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
 - **License:** MIT License (See [LICENSE](LICENSE) for details)
 - **Website:** [CodeGraphContext](http://codegraphcontext.vercel.app/)
@@ -201,7 +201,7 @@ A powerful **MCP server** and **CLI toolkit** that indexes local code into a gra
 -   **Interactive Setup:** A user-friendly command-line wizard for easy setup.
 -   **Dual Mode:** Works as a standalone **CLI toolkit** for developers and as an **MCP server** for AI agents.
 -   **Multi-Language Support:** Full support for 20 programming languages.
--   **Flexible Database Backend:** KuzuDB (Default), LadybugDB, FalkorDB Lite (Typical Unix default), FalkorDB Remote, Nornic DB, or Neo4j (all platforms via Docker/native).
+-   **Flexible Database Backend:** FalkorDB Lite (Default), KuzuDB, LadybugDB, FalkorDB Remote, Nornic DB, or Neo4j (all platforms via Docker/native).
 
 
 ---
@@ -304,8 +304,8 @@ _If you’re using CodeGraphContext in your project, feel free to open a PR and
 
 3.  **Database Setup (Automatic):**
     CodeGraphContext uses an embedded graph database by default.
-    - **KuzuDB:** Default for all platforms.
-    - **FalkorDB Lite:** Preferred on Unix/macOS if available.
+    - **FalkorDB Lite:** Default backend.
+    - **KuzuDB:** Cross-platform embedded backend.
     - **Neo4j:** Run `codegraphcontext neo4j setup` to use an external server.
 
 ---

{codegraphcontext-0.4.11.dist-info → codegraphcontext-0.4.12.dist-info}/RECORD

@@ -10,15 +10,15 @@ codegraphcontext/api/router.py,sha256=9LU6_5K7_sZCiYIhq6Pko4T6CZ5q8doM_e6rCgvQWM
 codegraphcontext/api/schemas.py,sha256=pGLuKtdn55pf8mS8wv8MwehbT_3-4OZuSYjI5LJxzOc,1034
 codegraphcontext/cli/__init__.py,sha256=2vUlnf7H09M9JbS2gS_LmMUBJWAWcGGHkkl4I2YrdSg,39
 codegraphcontext/cli/cli_helpers.py,sha256=_fksM3sBj9e96gQcHOaDmpmJG6444lWRaO0AM-6Wzu8,38773
-codegraphcontext/cli/config_manager.py,sha256=zMuRRRFWF8M46_lnBZ8I8z3HCWuk95OiymDYZ2JEHcs,44154
-codegraphcontext/cli/main.py,sha256=mRL-aqAf_vfbtvVzseidnroHt6OK25jpVnTuDSfsA2o,113636
-codegraphcontext/cli/registry_commands.py,sha256=mAJDYw1XUbzhj_SMM9PgO4MzECQj0OR3LU54x-OpPeU,15947
+codegraphcontext/cli/config_manager.py,sha256=Vx94GpLlP3TisW5Kp6yZ5p1mVJIsm-wldn0_3P0mY74,44511
+codegraphcontext/cli/main.py,sha256=COwBzgeAR1va4HmdyGfkCkAT6K4YmpVfYnMCIjF2IRk,116918
+codegraphcontext/cli/registry_commands.py,sha256=kM7KtC8-4q83SPHShWI1-xNsq91LvWuelT6xU0OzUHY,16543
 codegraphcontext/cli/setup_macos.py,sha256=Xjlv_9jk9qv8Gh7stpH1pvlalzC0Fg176y7jc5G1zh0,3575
 codegraphcontext/cli/setup_wizard.py,sha256=ssI_9v7yZXiML2sQ7IR3kwbKiG9riPskl-Qkc16ozVQ,47070
 codegraphcontext/cli/visualizer.py,sha256=md5HehQ9_8lBTejQqq2lxXtMRzDxCjjF9L9h2qu6KR0,1902
-codegraphcontext/core/__init__.py,sha256=hChhQcs1nDUnWmye1Q3pKK0F3sNNyB78R-3C3JGJy0Y,8603
-codegraphcontext/core/bundle_registry.py,sha256=vVetZrXbjHsqfAJzt8Pmm03pt1qK7pyH9NuHjVtJ7kI,7913
-codegraphcontext/core/cgc_bundle.py,sha256=NUEZwt_5LYFZwQcAGDnM9OFHa22f9XsCag20edxMsZM,36295
+codegraphcontext/core/__init__.py,sha256=Ob-2LzXhmt9-YdaND3OEGMeX0V6nBnTflOE5QGMCeho,8797
+codegraphcontext/core/bundle_registry.py,sha256=CJ4KasV7y2bbmajvz0W66N9IkZ3mdSkOM_kfQmUH37Y,7952
+codegraphcontext/core/cgc_bundle.py,sha256=mAaqe0Zz80EXZnD7gDEpq46JZes9vX_hU5oAn6PJGWU,38016
 codegraphcontext/core/cgcignore.py,sha256=6q7y11V_bNEhMC1167HiUyr7yxDCNg2OMr0DQAqCzlE,4213
 codegraphcontext/core/database.py,sha256=RWMdKKinoWewyTyTuIXX-fk7EHkba91LO18gZ12wwEg,14648
 codegraphcontext/core/database_falkordb.py,sha256=jpa7iTMSRs0k67adMihrCNzl8QnYlqKKHXDsvwW9880,21426
@@ -31,7 +31,7 @@ codegraphcontext/core/jobs.py,sha256=d6v_IERdEcDlIsz3CW3p0QMp3N-6dgQICs3FZRPgPgU
 codegraphcontext/core/watcher.py,sha256=EFjKYK3wUQG2pQter_A2xSe8yIrkZwfjZ9anITAjftA,18949
 codegraphcontext/tools/__init__.py,sha256=iqQPEkDlGXO7rAaLNQrS_ZAbLSklBSK-OowpARq0mig,41
 codegraphcontext/tools/advanced_language_query_tool.py,sha256=73tkiMc_4ez6dX8aQBD6WzKAWhBn7jbsdMDXwdFCvvk,3731
-codegraphcontext/tools/code_finder.py,sha256=yWajkHox9a50BXFPJI6ds8lxmeEgzr1wRwL-VXeFF2w,69579
+codegraphcontext/tools/code_finder.py,sha256=AZV51kDFmwIhHKQmH36zuL9qTlrP_RaP3e-ZEN_wi3k,70514
 codegraphcontext/tools/graph_builder.py,sha256=5t8G8eoSRTsjdqMtrZIxAK01I2_B3zToY3ab_GhdNrQ,54278
 codegraphcontext/tools/package_resolver.py,sha256=KtbdMReTezszjdsqYniL-Xb-QUsrAJWtf1NSiyIPkLI,18704
 codegraphcontext/tools/report_generator.py,sha256=K4AROEMZU--fX217JT6y7P7LfiqRnG8olwrj0vO1kKo,12499
@@ -107,7 +107,7 @@ codegraphcontext/tools/query_tool_languages/scala_toolkit.py,sha256=rCUKIpKyiWG2
 codegraphcontext/tools/query_tool_languages/swift_toolkit.py,sha256=fVhf6w2q6DmhQfQP08wEulMGzopG5B8axL3p59puZrI,274
 codegraphcontext/tools/query_tool_languages/typescript_toolkit.py,sha256=MUB0pVG2Bk6wBK0lXqaEwMxUQIcJugm3eeT_hLXJX3s,283
 codegraphcontext/utils/debug_log.py,sha256=PZfti8__3lYqgyyvdU41wARFW99nppcEX5DkFE9KeFY,2878
-codegraphcontext/utils/git_utils.py,sha256=6PWPeu7J8ezXDKX8CQbd-_LAp0-0q3HkY9E5P7n_TQ0,911
+codegraphcontext/utils/git_utils.py,sha256=D7ve2gpZaEHk4y6K4ga-o2ka89DVFX1acafD31YAyJM,1383
 codegraphcontext/utils/path_ignore.py,sha256=xaYCSq6nzUVX_mEdn3yrmwM--v7orJImga2XAQeiGB0,2168
 codegraphcontext/utils/repo_path.py,sha256=BxS3y6RV_WaZhg_WxgJygS4SnQa-Ryth2fsicfnYorY,1121
 codegraphcontext/utils/tool_limits.py,sha256=3d-QnlzxBNocz58VKNhdsta7ZpWThs1AX46_gYXl6pQ,2751
@@ -152,9 +152,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.4.11.dist-info/licenses/LICENSE,sha256=rh8M-bJpQYJnw2vtRVgt0t7piMZXh5QzaKeNEI0vqqA,1061
-codegraphcontext-0.4.11.dist-info/METADATA,sha256=E6Dhdu4zLUaLxfEkMgzd5quJH1IZJU5BC5dMbsuPDzc,22677
-codegraphcontext-0.4.11.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-codegraphcontext-0.4.11.dist-info/entry_points.txt,sha256=LCxWCWMshdvYGoHBPuQZ8C-e4CiNSHCLXofrNSGHkoE,103
-codegraphcontext-0.4.11.dist-info/top_level.txt,sha256=CBgc6LAPZIO5FS0nSYYkylDifHsZTIqw3Gf5UwDxeGI,17
-codegraphcontext-0.4.11.dist-info/RECORD,,
+codegraphcontext-0.4.12.dist-info/licenses/LICENSE,sha256=rh8M-bJpQYJnw2vtRVgt0t7piMZXh5QzaKeNEI0vqqA,1061
+codegraphcontext-0.4.12.dist-info/METADATA,sha256=ADQKPPW2ggEmk2ER9bFCD3MVL_rx3wnx1lAzIOScSsI,22639
+codegraphcontext-0.4.12.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+codegraphcontext-0.4.12.dist-info/entry_points.txt,sha256=LCxWCWMshdvYGoHBPuQZ8C-e4CiNSHCLXofrNSGHkoE,103
+codegraphcontext-0.4.12.dist-info/top_level.txt,sha256=CBgc6LAPZIO5FS0nSYYkylDifHsZTIqw3Gf5UwDxeGI,17
+codegraphcontext-0.4.12.dist-info/RECORD,,