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

codegraphcontext/cli/config_manager.py

@@ -30,6 +30,7 @@ DEFAULT_CONFIG = {
     "DEFAULT_DATABASE": "falkordb",
     "FALKORDB_PATH": str(CONFIG_DIR / "global" / "db" / "falkordb"),
     "FALKORDB_SOCKET_PATH": str(CONFIG_DIR / "global" / "db" / "falkordb.sock"),
+    "LADYBUGDB_PATH": str(CONFIG_DIR / "global" / "db" / "ladybugdb"),
     "INDEX_VARIABLES": "true",
     "ALLOW_DB_DELETION": "false",
     "DEBUG_LOGS": "false",
@@ -61,13 +62,16 @@ 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
 CONFIG_DESCRIPTIONS = {
-    "DEFAULT_DATABASE": "Default database backend (neo4j|falkordb|kuzudb|nornic)",
+    "DEFAULT_DATABASE": "Default database backend (neo4j|falkordb|falkordb-remote|kuzudb|nornic|ladybugdb)",
     "FALKORDB_PATH": "Path to FalkorDB database file",
     "FALKORDB_SOCKET_PATH": "Path to FalkorDB Unix socket",
+    "LADYBUGDB_PATH": "Path to LadybugDB database directory",
     "INDEX_VARIABLES": "Index variable nodes in the graph (lighter graph if false)",
     "ALLOW_DB_DELETION": "Allow full database deletion commands",
     "DEBUG_LOGS": "Enable debug logging (for development/troubleshooting)",
@@ -121,11 +125,15 @@ 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
 CONFIG_VALIDATORS = {
-    "DEFAULT_DATABASE": ["neo4j", "falkordb", "falkordb-remote", "kuzudb", "nornic"],
+    "DEFAULT_DATABASE": ["neo4j", "falkordb", "falkordb-remote", "kuzudb", "nornic", "ladybugdb"],
     "INDEX_VARIABLES": ["true", "false"],
     "ALLOW_DB_DELETION": ["true", "false"],
     "DEBUG_LOGS": ["true", "false"],
@@ -141,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
@@ -445,7 +454,7 @@ def validate_config_value(key: str, value: str) -> tuple[bool, Optional[str]]:
         except Exception as e:
             return False, f"Cannot create log directory: {e}"
     
-    if key in ("FALKORDB_PATH", "FALKORDB_SOCKET_PATH"):
+    if key in ("FALKORDB_PATH", "FALKORDB_SOCKET_PATH", "LADYBUGDB_PATH"):
         # Validate path is writable
         db_path = Path(normalize_config_path(value, absolute=True))
         try:

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)
@@ -280,8 +314,15 @@ class CGCBundle:
                                 if hasattr(node, attr):
                                     repo[attr] = getattr(node, attr)
                     
-                    metadata["repo"] = repo.get('name', str(repo_path))
-                    metadata["repo_path"] = repo.get('path')
+                    metadata["repo"] = repo.get('name', str(repo_path.name if repo_path else 'unknown'))
+                    # Clean up absolute path prefix to keep it relative
+                    meta_path = repo.get('path', '')
+                    if repo_path and meta_path.startswith(str(repo_path.resolve())):
+                        repo_str = str(repo_path.resolve())
+                        rel = meta_path[len(repo_str):].lstrip('/')
+                        metadata["repo_path"] = "./" + rel if rel else "."
+                    else:
+                        metadata["repo_path"] = meta_path
                     metadata["is_dependency"] = repo.get('is_dependency', False)
             else:
                 # All repositories
@@ -297,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("""
@@ -410,6 +454,14 @@ class CGCBundle:
                         elif hasattr(node, 'properties'):
                             node_dict = dict(node.properties)
                     
+                    # Clean up absolute path prefix to keep it relative
+                    if repo_path:
+                        repo_str = str(repo_path.resolve())
+                        for key, val in list(node_dict.items()):
+                            if isinstance(val, str) and val.startswith(repo_str):
+                                rel = val[len(repo_str):].lstrip('/')
+                                node_dict[key] = "./" + rel if rel else "."
+                    
                     node_dict['_labels'] = labels
                     
                     # Store internal ID for reference
@@ -480,6 +532,14 @@ class CGCBundle:
                         elif hasattr(rel, 'properties'):
                             rel_props = dict(rel.properties)
                     
+                    # Clean up absolute path prefix inside edge properties
+                    if repo_path:
+                        repo_str = str(repo_path.resolve())
+                        for key, val in list(rel_props.items()):
+                            if isinstance(val, str) and val.startswith(repo_str):
+                                rel = val[len(repo_str):].lstrip('/')
+                                rel_props[key] = "./" + rel if rel else "."
+                    
                     # Create edge representation
                     edge_dict = {
                         'from': from_id,