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

codegraphcontext/api/router.py

@@ -87,7 +87,7 @@ async def execute_query(
     server: MCPServer = Depends(get_server)
 ):
     result = await server.handle_tool_call("execute_cypher_query", {
-        "query": request.query,
+        "cypher_query": request.query,
         "params": request.params
     })
     

codegraphcontext/cli/config_manager.py

@@ -31,6 +31,7 @@ DEFAULT_CONFIG = {
     "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"),
+    "KUZUDB_PATH": str(CONFIG_DIR / "global" / "db" / "kuzudb"),
     "INDEX_VARIABLES": "true",
     "ALLOW_DB_DELETION": "false",
     "DEBUG_LOGS": "false",
@@ -62,6 +63,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
@@ -70,6 +73,7 @@ CONFIG_DESCRIPTIONS = {
     "FALKORDB_PATH": "Path to FalkorDB database file",
     "FALKORDB_SOCKET_PATH": "Path to FalkorDB Unix socket",
     "LADYBUGDB_PATH": "Path to LadybugDB database directory",
+    "KUZUDB_PATH": "Path to KuzuDB 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)",
@@ -123,6 +127,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 +151,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
@@ -447,7 +456,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", "LADYBUGDB_PATH"):
+    if key in ("FALKORDB_PATH", "FALKORDB_SOCKET_PATH", "LADYBUGDB_PATH", "KUZUDB_PATH"):
         # Validate path is writable
         db_path = Path(normalize_config_path(value, absolute=True))
         try:

codegraphcontext/cli/main.py

@@ -250,7 +250,7 @@ def context_list():
 @context_app.command("create")
 def context_create(
     name: str = typer.Argument(..., help="Name of the new context"),
-    database: str = typer.Option(None, "--database", "-d", help="Database backend (falkordb, kuzudb, neo4j). Defaults to DEFAULT_DATABASE from config."),
+    database: str = typer.Option(None, "--database", "--db", "-db", "-d", help="Database backend (falkordb, kuzudb, neo4j). Defaults to DEFAULT_DATABASE from config."),
     db_path: str = typer.Option(None, "--db-path", help="Explicit path for the DB (defaults to ~/.codegraphcontext/contexts/<name>/db)"),
 ):
     """Create a new logical context."""
@@ -285,23 +285,20 @@ 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.
     Priority order (highest to lowest):
     1. Runtime environment variables (shell/CI)
-    2. Local `.env` in project directory (project-specific overrides)
+    2. Local `.codegraphcontext/.env` and `.env` in the current project directory (project-specific overrides)
     3. Global `~/.codegraphcontext/.env` (user defaults, including `cgc config set`)
     4. Local `mcp.json` env vars (project defaults)
-    1. Local `mcp.json` env vars (highest - explicit MCP server config)
-    2. ``<cwd>/.codegraphcontext/.env`` only (no parent-directory walk)
-    3. Global `~/.codegraphcontext/.env` (lowest - user defaults)
 
-    Step 2 skips duplicate loading when that file is the same path as the global file.
-    Arbitrary repo-root `.env` files are not loaded—only CodeGraphContext config paths.
+    Duplicate loading is skipped when the local file resolves to the same path as the global file.
+    Arbitrary parent directory `.env` files are not loaded—ensuring isolation.
     """
-    from dotenv import dotenv_values, find_dotenv
+    from dotenv import dotenv_values
     from codegraphcontext.cli.config_manager import (
         ensure_config_dir,
         codegraphcontext_dotenv_at_cwd,
@@ -336,7 +333,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,15 +352,17 @@ 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]")
     
-    # 2. Local project .env (project-specific overrides)
+    # 2. Local project .env (project-specific overrides - restricted to CWD only, no parent walk)
     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))
+        local_dot_env = Path.cwd() / ".env"
+        if local_dot_env.exists() and local_dot_env.resolve() != global_env_path.resolve():
+            with open(local_dot_env, "r", encoding="utf-8", errors="replace") as f:
+                _append_source(str(local_dot_env), dotenv_values(stream=f))
     except Exception as e:
         console.print(f"[yellow]Warning: Could not load .env from current directory: {e}[/yellow]")
 
@@ -371,8 +370,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 +418,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 +486,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 +505,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 +569,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.
     
@@ -608,7 +634,7 @@ def bundle_export(
         if repo_path:
             console.print(f"[dim]Repository: {repo_path}[/dim]")
         else:
-            console.print(f"[dim]Exporting all repositories[/dim]")
+            console.print("[dim]Exporting all repositories[/dim]")
         
         bundle = CGCBundle(db_manager)
         success, message = bundle.export_to_bundle(
@@ -719,7 +745,7 @@ def bundle_load(
     
     # Try to download from registry
     console.print(f"[yellow]Bundle '{bundle_name}' not found locally.[/yellow]")
-    console.print(f"[cyan]Attempting to download from registry...[/cyan]")
+    console.print("[cyan]Attempting to download from registry...[/cyan]")
     
     try:
         from .registry_commands import download_bundle
@@ -739,7 +765,7 @@ def bundle_load(
     
     except Exception as e:
         console.print(f"[bold red]Error: {e}[/bold red]")
-        console.print(f"[dim]Use 'cgc registry list' to see available bundles[/dim]")
+        console.print("[dim]Use 'cgc registry list' to see available bundles[/dim]")
         raise typer.Exit(code=1)
 
 # Shortcut commands at root level
@@ -859,7 +885,7 @@ def registry_download(
     bundle_path = download_bundle(name, output_dir, auto_load=load)
     
     if load and bundle_path:
-        console.print(f"\n[cyan]Loading bundle...[/cyan]")
+        console.print("\n[cyan]Loading bundle...[/cyan]")
         bundle_import(bundle_path, clear=False)
 
 @registry_app.command("request")
@@ -912,13 +938,13 @@ def doctor():
         if config_manager.CONFIG_FILE.exists():
             console.print(f"   [green]✓[/green] Config loaded from {config_manager.CONFIG_FILE}")
         else:
-            console.print(f"   [yellow]ℹ[/yellow] No .env config found, using defaults")
+            console.print("   [yellow]ℹ[/yellow] No .env config found, using defaults")
             console.print(f"   [dim]Config will be created at: {config_manager.CONFIG_FILE}[/dim]")
             
         if config_manager.CONTEXT_CONFIG_FILE.exists():
             console.print(f"   [green]✓[/green] Context config loaded from {config_manager.CONTEXT_CONFIG_FILE}")
         else:
-            console.print(f"   [yellow]ℹ[/yellow] No Context config found")
+            console.print("   [yellow]ℹ[/yellow] No Context config found")
             console.print(f"   [dim]Context config will be auto-generated at: {config_manager.CONTEXT_CONFIG_FILE}[/dim]")
         
         # Validate each config value
@@ -929,12 +955,12 @@ def doctor():
                 invalid_configs.append(f"{key}: {error_msg}")
         
         if invalid_configs:
-            console.print(f"   [red]✗[/red] Invalid configuration values found:")
+            console.print("   [red]✗[/red] Invalid configuration values found:")
             for err in invalid_configs:
                 console.print(f"     - {err}")
             all_checks_passed = False
         else:
-            console.print(f"   [green]✓[/green] All configuration values are valid")
+            console.print("   [green]✓[/green] All configuration values are valid")
     except Exception as e:
         console.print(f"   [red]✗[/red] Configuration error: {e}")
         all_checks_passed = False
@@ -974,10 +1000,10 @@ def doctor():
                     console.print("       Start Neo4j Desktop or run: docker run -d -p 7687:7687 -p 7474:7474 neo4j")
                     all_checks_passed = False
 
-                console.print(f"   [cyan]Testing Neo4j authentication/query...[/cyan]")
+                console.print("   [cyan]Testing Neo4j authentication/query...[/cyan]")
                 is_connected, error_msg = DatabaseManager.test_connection(uri, username, password, database=database_name)
                 if is_connected:
-                    console.print(f"   [green]✓[/green] Neo4j connection successful")
+                    console.print("   [green]✓[/green] Neo4j connection successful")
                 else:
                     console.print(f"   [red]✗[/red] Neo4j connection failed (source: {db_source})")
                     console.print(f"       Reason: {error_msg}")
@@ -986,28 +1012,28 @@ def doctor():
             from importlib.util import find_spec
 
             if find_spec("kuzu") is not None:
-                console.print(f"   [green]✓[/green] KuzuDB is installed")
+                console.print("   [green]✓[/green] KuzuDB is installed")
             else:
-                console.print(f"   [red]✗[/red] KuzuDB is not installed")
-                console.print(f"       Run: pip install kuzu")
+                console.print("   [red]✗[/red] KuzuDB is not installed")
+                console.print("       Run: pip install kuzu")
                 all_checks_passed = False
         elif default_db == "ladybugdb":
             from importlib.util import find_spec
 
             if find_spec("ladybug") is not None:
-                console.print(f"   [green]✓[/green] LadybugDB core (ladybug) is installed")
+                console.print("   [green]✓[/green] LadybugDB core (ladybug) is installed")
             else:
-                console.print(f"   [red]✗[/red] LadybugDB core (ladybug) is not installed")
-                console.print(f"       Run: pip install ladybug")
+                console.print("   [red]✗[/red] LadybugDB core (ladybug) is not installed")
+                console.print("       Run: pip install ladybug")
                 all_checks_passed = False
         else:
             # FalkorDB
             try:
                 import falkordb
-                console.print(f"   [green]✓[/green] FalkorDB Lite is installed")
+                console.print("   [green]✓[/green] FalkorDB Lite is installed")
             except ImportError:
-                console.print(f"   [yellow]⚠[/yellow] FalkorDB Lite not installed (Python 3.12+ only)")
-                console.print(f"       Run: pip install falkordblite")
+                console.print("   [yellow]⚠[/yellow] FalkorDB Lite not installed (Python 3.12+ only)")
+                console.print("       Run: pip install falkordblite")
     except Exception as e:
         console.print(f"   [red]✗[/red] Database check error: {e}")
         all_checks_passed = False
@@ -1016,11 +1042,11 @@ def doctor():
     console.print("\n[bold]3. Checking Tree-Sitter Installation...[/bold]")
     try:
         from tree_sitter import Language, Parser
-        console.print(f"   [green]✓[/green] tree-sitter is installed")
+        console.print("   [green]✓[/green] tree-sitter is installed")
         
         try:
             from tree_sitter_language_pack import get_language
-            console.print(f"   [green]✓[/green] tree-sitter-language-pack is installed")
+            console.print("   [green]✓[/green] tree-sitter-language-pack is installed")
             
             from codegraphcontext.utils.tree_sitter_manager import LANGUAGE_ALIASES, LANGUAGE_PACK_NAMES
             all_langs = sorted(set(LANGUAGE_ALIASES.values()))
@@ -1038,7 +1064,7 @@ def doctor():
             if unavailable:
                 console.print(f"   [yellow]⚠[/yellow] Unavailable: {', '.join(unavailable)}")
         except ImportError:
-            console.print(f"   [red]✗[/red] tree-sitter-language-pack not installed")
+            console.print("   [red]✗[/red] tree-sitter-language-pack not installed")
             all_checks_passed = False
     except ImportError as e:
         console.print(f"   [red]✗[/red] tree-sitter not installed: {e}")
@@ -1056,12 +1082,12 @@ def doctor():
             try:
                 test_file.touch()
                 test_file.unlink()
-                console.print(f"   [green]✓[/green] Config directory is writable")
+                console.print("   [green]✓[/green] Config directory is writable")
             except Exception as e:
                 console.print(f"   [red]✗[/red] Config directory not writable: {e}")
                 all_checks_passed = False
         else:
-            console.print(f"   [yellow]⚠[/yellow] Config directory doesn't exist, will be created on first use")
+            console.print("   [yellow]⚠[/yellow] Config directory doesn't exist, will be created on first use")
     except Exception as e:
         console.print(f"   [red]✗[/red] Permission check error: {e}")
         all_checks_passed = False
@@ -1073,7 +1099,7 @@ def doctor():
     if cgc_path:
         console.print(f"   [green]✓[/green] cgc command found at: {cgc_path}")
     else:
-        console.print(f"   [yellow]⚠[/yellow] cgc command not in PATH (using python -m cgc)")
+        console.print("   [yellow]⚠[/yellow] cgc command not in PATH (using python -m cgc)")
     
     # Final summary
     console.print("\n" + "=" * 60)
@@ -1388,17 +1414,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 +1437,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 +1484,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 +2265,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 +2279,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 +2336,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()
 
@@ -2333,7 +2390,7 @@ def analyze_dead_code(
                 location_str
             )
         
-        console.print(f"\n[bold yellow]⚠️  Potentially Unused Functions:[/bold yellow]")
+        console.print("\n[bold yellow]⚠️  Potentially Unused Functions:[/bold yellow]")
         console.print(table)
         console.print(f"\n[dim]Total: {len(unused_funcs)} function(s)[/dim]")
         console.print(f"[dim]Note: {results.get('note', '')}[/dim]")