codegraphcontext 0.4.6__py3-none-any.whl → 0.4.8__py3-none-any.whl

codegraphcontext/cli/cli_helpers.py

@@ -2,10 +2,12 @@ import asyncio
 import json
 import uuid
 import urllib.parse
+from collections import Counter
 from pathlib import Path
 import time
 import os
 from typing import Optional, List, Dict, Any
+import typer
 from rich.console import Console
 from rich.table import Table
 from rich.progress import (
@@ -24,12 +26,38 @@ from ..tools.code_finder import CodeFinder
 from ..tools.graph_builder import GraphBuilder
 from ..tools.package_resolver import get_local_package_path
 from ..utils.debug_log import info_logger, warning_logger
+from ..core.database import Neo4jConnectionError
 from ..utils.repo_path import any_repo_matches_path
 from .config_manager import resolve_context, ResolvedContext, register_repo_in_context, ensure_first_run_bootstrap
 
 console = Console()
 
 
+def _print_call_resolution_diagnostics(graph_builder: GraphBuilder, limit: int = 5) -> None:
+    diagnostics = getattr(graph_builder, "last_call_resolution_diagnostics", [])
+    if not diagnostics:
+        return
+
+    reason_counts = Counter(d.get("reason", "unknown") for d in diagnostics)
+    summary = ", ".join(
+        f"{reason}={count}" for reason, count in reason_counts.most_common()
+    )
+    console.print(
+        f"[yellow]Skipped {len(diagnostics)} unresolved call relationship(s): {summary}[/yellow]"
+    )
+    table = Table(show_header=True, header_style="bold magenta")
+    table.add_column("Call", style="cyan", overflow="fold")
+    table.add_column("Reason", style="yellow")
+    table.add_column("Location", style="dim", overflow="fold")
+    for diagnostic in diagnostics[:limit]:
+        table.add_row(
+            str(diagnostic.get("full_call_name") or ""),
+            str(diagnostic.get("reason") or ""),
+            f"{diagnostic.get('caller_file_path')}:{diagnostic.get('line_number')}",
+        )
+    console.print(table)
+
+
 def _initialize_services(cli_context_flag: Optional[str] = None) -> tuple[Any, Any, Any, ResolvedContext]:
     """
     Initializes and returns core service managers based on the resolved context.
@@ -50,9 +78,14 @@ def _initialize_services(cli_context_flag: Optional[str] = None) -> tuple[Any, A
 
     console.print("[dim]Initializing services and database connection...[/dim]")
     try:
-        # Override the database backend with the context's specific choice
-        if ctx.database:
-            os.environ['CGC_RUNTIME_DB_TYPE'] = ctx.database
+        # Respect runtime/backend overrides. Context DB is only a default when
+        # neither runtime override nor DEFAULT_DATABASE is already set.
+        if (
+            ctx.database
+            and not os.getenv("CGC_RUNTIME_DB_TYPE")
+            and not os.getenv("DEFAULT_DATABASE")
+        ):
+            os.environ["DEFAULT_DATABASE"] = ctx.database
         
         # Pass the exact DB path resolved from the context
         db_manager = get_database_manager(db_path=ctx.db_path)
@@ -85,9 +118,35 @@ def _initialize_services(cli_context_flag: Optional[str] = None) -> tuple[Any, A
                 console.print(f"[bold red]Critical Error:[/bold red] Both FalkorDB and KùzuDB failed: {kuzu_e}")
                 return None, None, None, ctx
         else:
-            console.print(f"[bold red]Database Connection Error:[/bold red] {e}")
-            console.print("Please ensure your database is configured correctly or run 'cgc doctor'.")
-            return None, None, None, ctx
+            selected_db = (
+                os.environ.get("CGC_RUNTIME_DB_TYPE")
+                or os.environ.get("DATABASE_TYPE")
+                or os.environ.get("DEFAULT_DATABASE")
+                or ""
+            ).lower()
+
+            if isinstance(e, Neo4jConnectionError):
+                console.print(f"[bold red]{e}[/bold red]")
+                allow_fallback = os.environ.get("CGC_ALLOW_NEO4J_FALLBACK", "false").lower() in {"1", "true", "yes", "on"}
+
+                if selected_db == "neo4j" and allow_fallback:
+                    console.print("[cyan]Neo4j failed and CGC_ALLOW_NEO4J_FALLBACK=true. Falling back to KuzuDB...[/cyan]")
+                    try:
+                        from ..core.database_kuzu import KuzuDBManager
+                        db_manager = KuzuDBManager()
+                        db_manager.get_driver()
+                        console.print("[green]✓[/green] Successfully switched to KuzuDB fallback")
+                    except Exception as kuzu_e:
+                        console.print(f"[bold red]Critical Error:[/bold red] Neo4j failed and KuzuDB fallback failed: {kuzu_e}")
+                        return None, None, None, ctx
+                else:
+                    if selected_db == "neo4j":
+                        console.print("[yellow]Tip:[/yellow] To continue without Neo4j, rerun with --db kuzudb")
+                    return None, None, None, ctx
+            else:
+                console.print(f"[bold red]Database Connection Error:[/bold red] {e}")
+                console.print("Please ensure your database is configured correctly or run 'cgc doctor'.")
+                return None, None, None, ctx
     
     # The GraphBuilder requires an event loop, even for synchronous-style execution
     try:
@@ -211,6 +270,7 @@ def index_helper(path: str, context: Optional[str] = None):
         asyncio.run(_run_index_with_progress(graph_builder, path_obj, is_dependency=False, cgcignore_path=ctx.cgcignore_path))
         time_end = time.time()
         elapsed = time_end - time_start
+        _print_call_resolution_diagnostics(graph_builder)
         console.print(f"[green]Successfully finished indexing: {path} in {elapsed:.2f} seconds[/green]")
         
         # Check if auto-watch is enabled
@@ -227,6 +287,7 @@ def index_helper(path: str, context: Optional[str] = None):
             
     except Exception as e:
         console.print(f"[bold red]An error occurred during indexing:[/bold red] {e}")
+        raise typer.Exit(code=1)
     finally:
         db_manager.close_driver()
 
@@ -257,6 +318,7 @@ def add_package_helper(package_name: str, language: str, context: Optional[str]
 
     try:
         asyncio.run(_run_index_with_progress(graph_builder, package_path, is_dependency=True, cgcignore_path=ctx.cgcignore_path))
+        _print_call_resolution_diagnostics(graph_builder)
         console.print(f"[green]Successfully finished indexing package: {package_name}[/green]")
     except Exception as e:
         console.print(f"[bold red]An error occurred during package indexing:[/bold red] {e}")
@@ -322,9 +384,11 @@ def cypher_helper(query: str, context: Optional[str] = None):
 
     db_manager, _, _, ctx = services
     
-    # Replicating safety checks from MCPServer
+    # Replicating safety checks from MCPServer (using word boundaries to avoid false positives like 'createEmail')
+    import re
     forbidden_keywords = ['CREATE', 'MERGE', 'DELETE', 'SET', 'REMOVE', 'DROP', 'CALL apoc']
-    if any(keyword in query.upper() for keyword in forbidden_keywords):
+    pattern = r'\b(' + '|'.join(forbidden_keywords) + r')\b'
+    if re.search(pattern, query, re.IGNORECASE):
         console.print("[bold red]Error: This command only supports read-only queries.[/bold red]")
         db_manager.close_driver()
         return
@@ -350,9 +414,11 @@ def cypher_helper_visual(query: str, context: Optional[str] = None):
 
     db_manager, _, _, ctx = services
     
-    # Replicating safety checks from MCPServer
+    # Replicating safety checks from MCPServer (using word boundaries to avoid false positives like 'createEmail')
+    import re
     forbidden_keywords = ['CREATE', 'MERGE', 'DELETE', 'SET', 'REMOVE', 'DROP', 'CALL apoc']
-    if any(keyword in query.upper() for keyword in forbidden_keywords):
+    pattern = r'\b(' + '|'.join(forbidden_keywords) + r')\b'
+    if re.search(pattern, query, re.IGNORECASE):
         console.print("[bold red]Error: This command only supports read-only queries.[/bold red]")
         db_manager.close_driver()
         return
@@ -508,9 +574,11 @@ def reindex_helper(path: str, context: Optional[str] = None):
         asyncio.run(_run_index_with_progress(graph_builder, path_obj, is_dependency=False, cgcignore_path=ctx.cgcignore_path))
         time_end = time.time()
         elapsed = time_end - time_start
+        _print_call_resolution_diagnostics(graph_builder)
         console.print(f"[green]Successfully re-indexed: {path} in {elapsed:.2f} seconds[/green]")
     except Exception as e:
         console.print(f"[bold red]An error occurred during re-indexing:[/bold red] {e}")
+        raise typer.Exit(code=1)
     finally:
         db_manager.close_driver()
 
@@ -637,6 +705,12 @@ def stats_helper(path: str = None, context: Optional[str] = None):
                     class_count = session.run("MATCH (c:Class) RETURN count(c) as c").single()["c"]
                     module_count = session.run("MATCH (m:Module) RETURN count(m) as c").single()["c"]
                     
+                    # Extended node types (PHP, Rust, Go, etc.)
+                    interface_count = session.run("MATCH (i:Interface) RETURN count(i) as c").single()["c"]
+                    trait_count = session.run("MATCH (t:Trait) RETURN count(t) as c").single()["c"]
+                    struct_count = session.run("MATCH (s:Struct) RETURN count(s) as c").single()["c"]
+                    enum_count = session.run("MATCH (e:Enum) RETURN count(e) as c").single()["c"]
+                    
                     table = Table(show_header=True, header_style="bold magenta")
                     table.add_column("Metric", style="cyan")
                     table.add_column("Count", style="green", justify="right")
@@ -645,6 +719,14 @@ def stats_helper(path: str = None, context: Optional[str] = None):
                     table.add_row("Files", str(file_count))
                     table.add_row("Functions", str(func_count))
                     table.add_row("Classes", str(class_count))
+                    if interface_count > 0:
+                        table.add_row("Interfaces", str(interface_count))
+                    if trait_count > 0:
+                        table.add_row("Traits", str(trait_count))
+                    if struct_count > 0:
+                        table.add_row("Structs", str(struct_count))
+                    if enum_count > 0:
+                        table.add_row("Enums", str(enum_count))
                     table.add_row("Modules", str(module_count))
                     
                     console.print(table)

codegraphcontext/cli/config_manager.py

@@ -48,13 +48,18 @@ DEFAULT_CONFIG = {
     "INDEX_SOURCE": "true",
     # SCIP indexer feature flag (default off — existing Tree-sitter behaviour unchanged)
     "SCIP_INDEXER": "false",
-    "SCIP_LANGUAGES": "python,typescript,go,rust,java",
+    "SCIP_LANGUAGES": "python,typescript,javascript,go,rust,java,dart,cpp,c,csharp",
     "SKIP_EXTERNAL_RESOLUTION": "false",
     # 0 = unlimited; any positive integer caps MCP tool response size.
     "MAX_TOOL_RESPONSE_TOKENS": "0",
     # JSON object mapping tool names to integer result-count limits.
     # Example: {"find_code": 20, "analyze_code_relationships": 10, "find_dead_code": 30}
     "TOOL_RESULT_LIMITS": "{}",
+    # Post-indexing resolution phases (default off)
+    "ENABLE_INHERIT_RESOLVE": "false",
+    "ENABLE_VECTOR_RESOLVE": "false",
+    "CGC_EMBEDDING_MODEL": "local",
+    "CGC_EMBEDDING_BATCH_SIZE": "256",
 }
 
 # Configuration key descriptions
@@ -80,10 +85,41 @@ CONFIG_DESCRIPTIONS = {
     "IGNORE_DIRS": "Comma-separated list of directory names to ignore during indexing",
     "INDEX_SOURCE": "Store full source code in graph database (for faster indexing use false, for better performance use true)",
     "SCIP_INDEXER": "Use SCIP-based indexing for higher accuracy call/inheritance resolution (requires scip-<lang> tools installed)",
-    "SCIP_LANGUAGES": "Comma-separated languages to index via SCIP when SCIP_INDEXER=true (python,typescript,go,rust,java)",
+    "SCIP_LANGUAGES": "Comma-separated languages to index via SCIP when SCIP_INDEXER=true (python,typescript,javascript,go,rust,java,dart,cpp,c,csharp)",
     "SKIP_EXTERNAL_RESOLUTION": "Skip resolution attempts for external library method calls (recommended for enterprise large Java/Spring codebases)",
     "MAX_TOOL_RESPONSE_TOKENS": "Maximum tokens per MCP tool response (0 = unlimited). Truncates oversized payloads and appends a notice.",
     "TOOL_RESULT_LIMITS": "JSON object mapping tool names to max result counts, e.g. {\"find_code\": 20, \"analyze_code_relationships\": 10}. Missing keys use built-in defaults.",
+    # Post-indexing resolution phases
+    "ENABLE_INHERIT_RESOLVE": (
+        "[Phase 5] Re-resolve ambiguous same-file CALLS edges using the inheritance graph (INHERITS relationships). "
+        "When enabled, methods called on an interface or abstract class are re-pointed to the correct concrete "
+        "implementation based on the class hierarchy, reducing tier-7 fallback edges. "
+        "WHEN TO ENABLE: any Java/Kotlin/C# codebase that uses inheritance or interface-based DI (e.g. Spring, OSGi). "
+        "PREREQUISITES: run 'cgc index' first so INHERITS edges exist in the graph. No extra tools needed. "
+        "COST: adds ~1-5 min per 50K functions at the end of each 'cgc index' run. Safe to toggle on/off — only adds new edges, never removes existing ones."
+    ),
+    "ENABLE_VECTOR_RESOLVE": (
+        "[Phase 4 + Phase 5 tiebreaker] Generate semantic embeddings for all Function nodes and use vector "
+        "similarity as a tiebreaker when inheritance resolution alone cannot distinguish between multiple candidates. "
+        "Phase 4 writes a 384-dim embedding to every Function node; Phase 5 queries those embeddings during re-resolution. "
+        "WHEN TO ENABLE: large codebases (>10K functions) where inheritance alone leaves many ambiguous calls "
+        "(tier-7 fallbacks still high after ENABLE_INHERIT_RESOLVE). Also useful for cross-language repos. "
+        "PREREQUISITES: (1) fastembed must be installed — run 'pip install fastembed'. "
+        "(2) Neo4j must be the active database (vector index not supported on FalkorDB/KuzuDB). "
+        "(3) ENABLE_INHERIT_RESOLVE should also be true — vector is a tiebreaker for Phase 5, not a replacement. "
+        "COST: Phase 4 takes ~15 min per 50K functions on CPU (first run only; incremental updates are fast). "
+        "Embedding model (~40 MB) is downloaded automatically on first use from HuggingFace."
+    ),
+    "CGC_EMBEDDING_MODEL": (
+        "Embedding backend for ENABLE_VECTOR_RESOLVE. "
+        "'local' uses fastembed (BAAI/bge-small-en-v1.5, 384-dim, runs on CPU, no GPU or API key needed). "
+        "'openai' uses OpenAI text-embedding-3-small (requires OPENAI_API_KEY env var, costs money per token). "
+        "Default: local"
+    ),
+    "CGC_EMBEDDING_BATCH_SIZE": (
+        "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."
+    ),
 }
 
 # Valid values for each config key
@@ -101,6 +137,9 @@ CONFIG_VALIDATORS = {
     "INDEX_SOURCE": ["true", "false"],
     "SCIP_INDEXER": ["true", "false"],
     "SKIP_EXTERNAL_RESOLUTION": ["true", "false"],
+    "ENABLE_INHERIT_RESOLVE": ["true", "false"],
+    "ENABLE_VECTOR_RESOLVE": ["true", "false"],
+    "CGC_EMBEDDING_MODEL": ["local", "openai"],
 }
 DEFAULT_CGCIGNORE_PATTERNS = """\
 # Default .cgcignore patterns
@@ -820,7 +859,7 @@ def resolve_context(
             )
 
     # --- 4. Global fallback ---
-    db = load_config().get("DEFAULT_DATABASE", "falkordb")
+    db = os.getenv("CGC_RUNTIME_DB_TYPE") or load_config().get("DEFAULT_DATABASE", "falkordb")
     return ResolvedContext(
         mode="global",
         context_name="",