codegraphcontext 0.4.6__tar.gz → 0.4.7__tar.gz

{codegraphcontext-0.4.6/src/codegraphcontext.egg-info → codegraphcontext-0.4.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codegraphcontext
-Version: 0.4.6
+Version: 0.4.7
 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
@@ -54,7 +54,7 @@ Requires-Dist: falkordb>=0.1.0
 Requires-Dist: requests>=2.28.0
 Requires-Dist: protobuf<3.21,>=3.20
 Requires-Dist: falkordblite>=0.1.0; sys_platform != "win32" and python_version >= "3.12"
-Requires-Dist: real_ladybug; sys_platform == "win32" or (sys_platform != "win32" and python_version >= "3.10")
+Requires-Dist: kuzu; sys_platform == "win32" or (sys_platform != "win32" and python_version >= "3.10")
 Requires-Dist: fastapi>=0.100.0
 Requires-Dist: uvicorn>=0.22.0
 Provides-Extra: parsing
@@ -166,7 +166,7 @@ A powerful **MCP server** and **CLI toolkit** that indexes local code into a gra
 ---
 
 ## Project Details
-- **Version:** 0.4.6
+- **Version:** 0.4.7
 - **Authors:** Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
 - **License:** MIT License (See [LICENSE](LICENSE) for details)
 - **Website:** [CodeGraphContext](http://codegraphcontext.vercel.app/)

{codegraphcontext-0.4.6 → codegraphcontext-0.4.7}/README.md

@@ -97,7 +97,7 @@ A powerful **MCP server** and **CLI toolkit** that indexes local code into a gra
 ---
 
 ## Project Details
-- **Version:** 0.4.6
+- **Version:** 0.4.7
 - **Authors:** Shashank Shekhar Singh <shashankshekharsingh1205@gmail.com>
 - **License:** MIT License (See [LICENSE](LICENSE) for details)
 - **Website:** [CodeGraphContext](http://codegraphcontext.vercel.app/)

{codegraphcontext-0.4.6 → codegraphcontext-0.4.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codegraphcontext"
-version = "0.4.6"
+version = "0.4.7"
 description = "An MCP server that indexes local code into a graph database to provide context to AI assistants."
 authors = [{ name = "Shashank Shekhar Singh", email = "shashankshekharsingh1205@gmail.com" }]
 readme = "README.md"
@@ -33,7 +33,7 @@ dependencies = [
     "requests>=2.28.0",
     "protobuf>=3.20,<3.21",
     "falkordblite>=0.1.0; sys_platform != 'win32' and python_version >= '3.12'",
-    "real_ladybug; sys_platform == 'win32' or (sys_platform != 'win32' and python_version >= '3.10')",
+    "kuzu; sys_platform == 'win32' or (sys_platform != 'win32' and python_version >= '3.10')",
     "fastapi>=0.100.0",
     "uvicorn>=0.22.0"
 ]

{codegraphcontext-0.4.6 → codegraphcontext-0.4.7}/src/codegraphcontext/cli/cli_helpers.py

@@ -24,6 +24,7 @@ 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
 
@@ -50,9 +51,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 +91,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:

{codegraphcontext-0.4.6 → codegraphcontext-0.4.7}/src/codegraphcontext/cli/config_manager.py

@@ -55,6 +55,11 @@ DEFAULT_CONFIG = {
     # 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
@@ -84,6 +89,37 @@ CONFIG_DESCRIPTIONS = {
     "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

{codegraphcontext-0.4.6 → codegraphcontext-0.4.7}/src/codegraphcontext/cli/main.py

@@ -109,7 +109,7 @@ def mcp_setup():
     Sets up CodeGraphContext integration with your IDE or CLI tool:
     - VS Code, Cursor, Windsurf
     - Claude Desktop, Gemini CLI
-    - Cline, RooCode, Amazon Q Developer
+    - Cline, RooCode, Amazon Q Developer, Goose
     - OpenCode (prints stdio config + link to vendor docs)
     
     Works with FalkorDB by default (no database setup needed).
@@ -289,6 +289,10 @@ def _load_credentials():
     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)
+    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)
@@ -305,19 +309,54 @@ def _load_credentials():
     # Ensure config directory exists (lazy initialization)
     ensure_config_dir()
     
-    # Collect all config sources in reverse priority order (lowest to highest)
+    # Snapshot runtime environment BEFORE merging config files.
+    # These values must remain highest priority.
+    runtime_env = dict(os.environ)
+
+    # Collect all config sources in precedence order (lowest to highest)
     config_sources = []
     config_source_names = []
+    key_source_map = {}
+    key_defined_in = {}
+
+    def _append_source(source_name: str, source_values: dict):
+        if not source_values:
+            return
+        config_sources.append(source_values)
+        config_source_names.append(source_name)
+        for k, v in source_values.items():
+            if v is None:
+                continue
+            key_source_map[k] = source_name
+            key_defined_in.setdefault(k, []).append(source_name)
+
+    # 4. Local mcp.json (lowest priority - project defaults)
+    mcp_file_path = Path.cwd() / "mcp.json"
+    if mcp_file_path.exists():
+        try:
+            with open(mcp_file_path, "r") as f:
+                mcp_config = json.load(f)
+            server_env = mcp_config.get("mcpServers", {}).get("CodeGraphContext", {}).get("env", {})
+            _append_source("mcp.json", server_env)
+        except Exception as e:
+            console.print(f"[yellow]Warning: Could not load mcp.json: {e}[/yellow]")
     
-    # 3. Global .env file (lowest priority - user defaults)
+    # 3. Global .env file (user defaults)
     global_env_path = Path.home() / ".codegraphcontext" / ".env"
     if global_env_path.exists():
         try:
-            config_sources.append(dotenv_values(str(global_env_path)))
-            config_source_names.append(str(global_env_path))
+            _append_source(str(global_env_path), dotenv_values(str(global_env_path)))
         except Exception as e:
             console.print(f"[yellow]Warning: Could not load global .env: {e}[/yellow]")
     
+    # 2. Local project .env (project-specific overrides)
+    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))
+    except Exception as e:
+        console.print(f"[yellow]Warning: Could not load .env from current directory: {e}[/yellow]")
+
     # 2. <cwd>/.codegraphcontext/.env only (overrides global when distinct)
     try:
         local_cgc_env = codegraphcontext_dotenv_at_cwd(Path.cwd())
@@ -329,24 +368,12 @@ def _load_credentials():
             f"[yellow]Warning: Could not load .codegraphcontext/.env at cwd: {e}[/yellow]"
         )
     
-    # 1. Local mcp.json (highest priority - explicit MCP server config)
-    mcp_file_path = Path.cwd() / "mcp.json"
-    if mcp_file_path.exists():
-        try:
-            with open(mcp_file_path, "r") as f:
-                mcp_config = json.load(f)
-            server_env = mcp_config.get("mcpServers", {}).get("CodeGraphContext", {}).get("env", {})
-            if server_env:
-                config_sources.append(server_env)
-                config_source_names.append("mcp.json")
-        except Exception as e:
-            console.print(f"[yellow]Warning: Could not load mcp.json: {e}[/yellow]")
-    
     # Merge all configs with proper precedence (later sources override earlier ones)
     merged_config = {}
     for config in config_sources:
         merged_config.update(config)
     
+    # Apply merged config to environment, but never override runtime env.
     # Apply merged config to environment.
     # IMPORTANT: DB-selection keys set in the shell must win over .env defaults.
     # E.g. `DEFAULT_DATABASE=falkordb cgc index …` must not be overridden by
@@ -354,8 +381,7 @@ def _load_credentials():
     DB_OVERRIDE_KEYS = {"CGC_RUNTIME_DB_TYPE", "DEFAULT_DATABASE"}
     for key, value in merged_config.items():
         if value is not None:  # Only set non-None values
-            # Never let .env clobber a DB-type key that the user already set in the shell
-            if key in DB_OVERRIDE_KEYS and key in os.environ:
+            if key in runtime_env:
                 continue
             os.environ[key] = str(value)
     
@@ -364,15 +390,43 @@ def _load_credentials():
         if len(config_source_names) == 1:
             console.print(f"[dim]Loaded configuration from: {config_source_names[-1]}[/dim]")
         else:
-            console.print(f"[dim]Loaded configuration from: {', '.join(config_source_names)} (highest priority: {config_source_names[-1]})[/dim]")
+            console.print(f"[dim]Loaded configuration from: {', '.join(config_source_names)}[/dim]")
     else:
         console.print("[yellow]No configuration file found. Using defaults.[/yellow]")
+
+    default_db_sources = list(key_defined_in.get("DEFAULT_DATABASE", []))
+    if "DEFAULT_DATABASE" in runtime_env:
+        default_db_sources.append("environment")
+
+    if len(default_db_sources) > 1:
+        winners = "environment" if "DEFAULT_DATABASE" in runtime_env else key_source_map.get("DEFAULT_DATABASE", "defaults")
+        console.print(
+            "[dim]DEFAULT_DATABASE defined in multiple sources: "
+            f"{', '.join(default_db_sources)}; using: {winners}[/dim]"
+        )
     
     
     # 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")
+
+    explicit_db = runtime_db or database_type or default_database
+
+    if runtime_db:
+        db_source = "runtime-env (CGC_RUNTIME_DB_TYPE)"
+    elif "DATABASE_TYPE" in runtime_env:
+        db_source = "environment (DATABASE_TYPE)"
+    elif "DEFAULT_DATABASE" in runtime_env:
+        db_source = "environment (DEFAULT_DATABASE)"
+    elif database_type and "DATABASE_TYPE" in key_source_map:
+        db_source = key_source_map["DATABASE_TYPE"]
+    elif default_database and "DEFAULT_DATABASE" in key_source_map:
+        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:
@@ -387,6 +441,7 @@ def _load_credentials():
             # Factory failed entirely — still show a best-guess
             from codegraphcontext.core import _is_falkordb_available
             default_db = "falkordb" if _is_falkordb_available() else "kuzudb"
+        db_source = "auto-detect"
 
     if default_db == "neo4j":
         has_neo4j_creds = all([
@@ -397,25 +452,35 @@ def _load_credentials():
         if has_neo4j_creds:
             neo4j_db = os.environ.get("NEO4J_DATABASE")
             if neo4j_db:
-                console.print(f"[cyan]Using database: Neo4j (database: {neo4j_db})[/cyan]")
+                console.print(f"[cyan]Using database: neo4j (source: {db_source}, database: {neo4j_db})[/cyan]")
             else:
-                console.print("[cyan]Using database: Neo4j[/cyan]")
+                console.print(f"[cyan]Using database: neo4j (source: {db_source})[/cyan]")
         else:
             console.print("[yellow]⚠ DEFAULT_DATABASE=neo4j but credentials not found. Falling back to default.[/yellow]")
     elif default_db == "falkordb":
-        console.print("[cyan]Using database: FalkorDB Lite[/cyan]")
+        console.print(f"[cyan]Using database: falkordb (source: {db_source})[/cyan]")
     elif default_db == "kuzudb":
-        console.print("[cyan]Using database: KùzuDB[/cyan]")
+        console.print(f"[cyan]Using database: kuzudb (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 ({host})[/cyan]")
+            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}[/cyan]")
+        console.print(f"[cyan]Using database: {default_db} (source: {db_source})[/cyan]")
+
+    # Persist selection metadata for downstream diagnostics and error messages.
+    os.environ["CGC_SELECTED_DATABASE"] = default_db
+    os.environ["CGC_DB_SELECTION_SOURCE"] = db_source
 
 
 
@@ -833,24 +898,45 @@ def doctor():
     console.print("\n[bold]2. Checking Database Connection...[/bold]")
     try:
         _load_credentials()
-        default_db = config.get("DEFAULT_DATABASE", "falkordb")
-        console.print(f"   Default database: {default_db}")
+        default_db = os.environ.get("CGC_SELECTED_DATABASE") or config.get("DEFAULT_DATABASE", "falkordb")
+        db_source = os.environ.get("CGC_DB_SELECTION_SOURCE", "unknown")
+        console.print(f"   Default database: {default_db} (source: {db_source})")
         
         if default_db == "neo4j":
             uri = os.environ.get("NEO4J_URI")
             username = os.environ.get("NEO4J_USERNAME")
             password = os.environ.get("NEO4J_PASSWORD")
-            
-            if uri and username and password:
-                console.print(f"   [cyan]Testing Neo4j connection to {uri}...[/cyan]")
-                is_connected, error_msg = DatabaseManager.test_connection(uri, username, password, database=os.environ.get("NEO4J_DATABASE"))
+            database_name = os.environ.get("NEO4J_DATABASE")
+
+            missing = DatabaseManager.get_missing_credentials(uri, username, password)
+            console.print(f"   [cyan]Credential check:[/cyan] {'OK' if not missing else 'Missing ' + ', '.join(missing)}")
+            if missing:
+                console.print("   [red]✗[/red] Neo4j credentials not configured")
+                console.print("       Run:")
+                console.print("       cgc config set NEO4J_URI bolt://localhost:7687")
+                console.print("       cgc config set NEO4J_USERNAME neo4j")
+                console.print("       cgc config set NEO4J_PASSWORD <your-password>")
+                all_checks_passed = False
+            else:
+                host, port = DatabaseManager.extract_host_port(uri)
+                console.print(f"   [cyan]Endpoint:[/cyan] {host}:{port}")
+
+                is_reachable, reachability_msg = DatabaseManager.check_port_reachable(uri)
+                if is_reachable:
+                    console.print(f"   [green]✓[/green] Port {port} is reachable")
+                else:
+                    console.print(f"   [red]✗[/red] Port check failed: {reachability_msg}")
+                    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]")
+                is_connected, error_msg = DatabaseManager.test_connection(uri, username, password, database=database_name)
                 if is_connected:
                     console.print(f"   [green]✓[/green] Neo4j connection successful")
                 else:
-                    console.print(f"[red]✗[/red] Neo4j connection failed: {error_msg}")
+                    console.print(f"   [red]✗[/red] Neo4j connection failed (source: {db_source})")
+                    console.print(f"       Reason: {error_msg}")
                     all_checks_passed = False
-            else:
-                console.print(f"   [yellow]⚠[/yellow] Neo4j credentials not set. Run 'cgc neo4j setup'")
         elif default_db == "kuzudb":
             from importlib.util import find_spec
 
@@ -1093,6 +1179,46 @@ def delete(
         
         delete_helper(path, context)
 
+
+@app.command()
+def report(
+    output: Optional[str] = typer.Option(None, "--output", "-o", help="Output file path. Defaults to CGC_REPORT.md in the current directory."),
+    java: bool = typer.Option(False, "--java", "-j", help="Include Spring/Maven Java sections."),
+    context: Optional[str] = typer.Option(None, "--context", "-c", help="Specific context to use"),
+):
+    """
+    Generate a CGC_REPORT.md with god nodes, complexity, cross-module connections, and suggested queries.
+
+    Use --java to also include Spring endpoint tables, bean stereotype counts,
+    and Maven module dependency summaries.
+
+    Examples:
+        cgc report
+        cgc report --output /tmp/my_report.md
+        cgc report --java
+    """
+    _load_credentials()
+    output_path = Path(output) if output else Path.cwd() / "CGC_REPORT.md"
+    db_manager, _, _ = _initialize_services(context)
+    try:
+        from codegraphcontext.tools.report_generator import generate_report
+        report_text = generate_report(db_manager, output_path=output_path, include_java=java)
+        console.print(f"[green]✓[/green] Report written to [bold]{output_path}[/bold]")
+        # Print a short preview (first ~40 lines)
+        preview_lines = report_text.splitlines()[:40]
+        console.print("\n".join(preview_lines))
+        if len(report_text.splitlines()) > 40:
+            console.print(f"[dim]... ({len(report_text.splitlines())} lines total, see {output_path})[/dim]")
+    except Exception as exc:
+        console.print(f"[red]Report generation failed:[/red] {exc}")
+        raise typer.Exit(code=1)
+    finally:
+        try:
+            db_manager.close_driver()
+        except Exception:
+            pass
+
+
 @app.command()
 def visualize(
     repo: Optional[str] = typer.Option(None, "--repo", "-r", help="Path to the repository to visualize."),
@@ -1177,7 +1303,7 @@ def unwatch(
     _load_credentials()
     unwatch_helper(path)
 
-@app.command()
+@app.command("watching")
 def watching(
     context: Optional[str] = typer.Option(None, "--context", "-c", help="Specific context to use"),
 ):
@@ -2321,6 +2447,7 @@ def main(
     database: Optional[str] = typer.Option(
         None, 
         "--database", 
+        "--db",
         "-db", 
         help="[Global] Temporarily override database backend (falkordb, falkordb-remote, neo4j, or kuzudb) for any command"
     ),
@@ -2382,5 +2509,149 @@ def main(
         console.print("👉 Running [green]codegraphcontext[/green] works the same as using [green]cgc[/green]")
 
 
+# ============================================================================
+# DATASOURCE COMMAND GROUP — Index external data sources (#843)
+# ============================================================================
+
+datasource_app = typer.Typer(help="Index external data sources (Redis, Cassandra, Aurora MySQL) into the code graph")
+app.add_typer(datasource_app, name="datasource")
+
+
+@datasource_app.command("mysql")
+def datasource_mysql(
+    ctx: typer.Context,
+    host: str = typer.Option(..., "--host", "-H", help="MySQL host / Aurora endpoint"),
+    port: int = typer.Option(3306, "--port", "-p", help="MySQL port"),
+    user: str = typer.Option(..., "--user", "-u", help="MySQL username"),
+    password: str = typer.Option(..., "--password", "-P", help="MySQL password", hide_input=True),
+    database: str = typer.Option(..., "--database", "-d", help="Database / schema name"),
+    name: Optional[str] = typer.Option(None, "--name", "-n", help="Logical datasource name (default: mysql-<database>)"),
+    env: str = typer.Option("production", "--env", "-e", help="Deployment environment label"),
+    context: Optional[str] = typer.Option(None, "--context", "-c", help="CGC context to use"),
+):
+    """Ingest Aurora MySQL schema (tables + columns) and write to the code graph.
+
+    Requires: pip install PyMySQL
+    """
+    try:
+        from codegraphcontext.tools.datasources.mysql_ingester import ingest as mysql_ingest
+    except ImportError as e:
+        console.print(f"[red]Import error:[/red] {e}")
+        raise typer.Exit(1)
+
+    if context:
+        config_manager.set_config_value("CONTEXT", context)
+
+    console.print(f"[cyan]Connecting to Aurora MySQL at {host}:{port}/{database}...[/cyan]")
+    try:
+        result = mysql_ingest(host=host, port=port, user=user, password=password,
+                               database=database, name=name, env=env)
+    except Exception as exc:
+        console.print(f"[red]Failed to connect / ingest:[/red] {exc}")
+        raise typer.Exit(1)
+
+    _write_datasource_graph(result)
+    console.print(
+        f"[green]✓ MySQL datasource[/green] [bold]{result['datasource']['name']}[/bold] indexed: "
+        f"{len(result.get('tables', []))} tables, {len(result.get('columns', []))} columns"
+    )
+
+
+@datasource_app.command("cassandra")
+def datasource_cassandra(
+    ctx: typer.Context,
+    host: str = typer.Option(..., "--host", "-H", help="Cassandra contact point (comma-separated for multiple)"),
+    port: int = typer.Option(9042, "--port", "-p", help="Cassandra native transport port"),
+    keyspace: str = typer.Option(..., "--keyspace", "-k", help="Keyspace to ingest"),
+    username: Optional[str] = typer.Option(None, "--user", "-u", help="Cassandra username"),
+    password: Optional[str] = typer.Option(None, "--password", "-P", help="Cassandra password", hide_input=True),
+    name: Optional[str] = typer.Option(None, "--name", "-n", help="Logical datasource name (default: cassandra-<keyspace>)"),
+    env: str = typer.Option("production", "--env", "-e", help="Deployment environment label"),
+    context: Optional[str] = typer.Option(None, "--context", "-c", help="CGC context to use"),
+):
+    """Ingest Cassandra keyspace schema (tables + columns) and write to the code graph.
+
+    Requires: pip install cassandra-driver
+    """
+    try:
+        from codegraphcontext.tools.datasources.cassandra_ingester import ingest as cassandra_ingest
+    except ImportError as e:
+        console.print(f"[red]Import error:[/red] {e}")
+        raise typer.Exit(1)
+
+    if context:
+        config_manager.set_config_value("CONTEXT", context)
+
+    hosts = [h.strip() for h in host.split(",")]
+    console.print(f"[cyan]Connecting to Cassandra at {hosts}/{keyspace}...[/cyan]")
+    try:
+        result = cassandra_ingest(hosts=hosts, port=port, keyspace=keyspace,
+                                   username=username, password=password, name=name, env=env)
+    except Exception as exc:
+        console.print(f"[red]Failed to connect / ingest:[/red] {exc}")
+        raise typer.Exit(1)
+
+    _write_datasource_graph(result)
+    console.print(
+        f"[green]✓ Cassandra datasource[/green] [bold]{result['datasource']['name']}[/bold] indexed: "
+        f"{len(result.get('tables', []))} tables, {len(result.get('columns', []))} columns"
+    )
+
+
+@datasource_app.command("redis")
+def datasource_redis(
+    ctx: typer.Context,
+    host: str = typer.Option(..., "--host", "-H", help="Redis host"),
+    port: int = typer.Option(6379, "--port", "-p", help="Redis port"),
+    db: int = typer.Option(0, "--db", help="Redis database index"),
+    password: Optional[str] = typer.Option(None, "--password", "-P", help="Redis AUTH password", hide_input=True),
+    name: Optional[str] = typer.Option(None, "--name", "-n", help="Logical datasource name"),
+    env: str = typer.Option("production", "--env", "-e", help="Deployment environment label"),
+    max_keys: int = typer.Option(10000, "--max-keys", help="Maximum keys to scan (avoid full scan in large clusters)"),
+    context: Optional[str] = typer.Option(None, "--context", "-c", help="CGC context to use"),
+):
+    """Discover Redis key patterns and write to the code graph.
+
+    Scans up to --max-keys keys and groups them into patterns (e.g. user:*).
+
+    Requires: pip install redis
+    """
+    try:
+        from codegraphcontext.tools.datasources.redis_ingester import ingest as redis_ingest
+    except ImportError as e:
+        console.print(f"[red]Import error:[/red] {e}")
+        raise typer.Exit(1)
+
+    if context:
+        config_manager.set_config_value("CONTEXT", context)
+
+    console.print(f"[cyan]Connecting to Redis at {host}:{port}/{db}...[/cyan]")
+    try:
+        result = redis_ingest(host=host, port=port, db=db, password=password,
+                               name=name, env=env, max_keys=max_keys)
+    except Exception as exc:
+        console.print(f"[red]Failed to connect / ingest:[/red] {exc}")
+        raise typer.Exit(1)
+
+    _write_datasource_graph(result)
+    console.print(
+        f"[green]✓ Redis datasource[/green] [bold]{result['datasource']['name']}[/bold] indexed: "
+        f"{len(result.get('key_patterns', []))} key patterns"
+    )
+
+
+def _write_datasource_graph(ingested: dict) -> None:
+    """Shared helper: write ingested datasource dict to the active graph."""
+    from codegraphcontext.core.database import DatabaseManager
+    dm = DatabaseManager()
+    driver = dm.get_driver()
+    if driver is None:
+        console.print("[red]No active graph connection. Run[/red] cgc context switch <name> [red]first.[/red]")
+        raise typer.Exit(1)
+
+    from codegraphcontext.tools.indexing.persistence.writer import GraphWriter
+    GraphWriter(driver).write_datasource_graph(ingested)
+
+
 if __name__ == "__main__":
     app()