codegraphcontext 0.4.16__py3-none-any.whl → 0.4.17__py3-none-any.whl

codegraphcontext/api/router.py

@@ -13,6 +13,8 @@ from .schemas import (
 )
 from codegraphcontext.server import MCPServer
 
+import socket
+
 router = APIRouter()
 
 # Global server instance (initialized on startup)
@@ -25,9 +27,19 @@ def get_server() -> MCPServer:
         _server_instance = MCPServer(cwd=Path.cwd())
     return _server_instance
 
+def raise_service_unavailable(exc: Exception):
+    raise HTTPException(
+        status_code=503,
+        detail="Database service unavailable",
+    ) from exc
+
 @router.get("/status", response_model=ApiResponse)
 async def get_status(server: MCPServer = Depends(get_server)):
-    status = server.db_manager.is_connected()
+    try:
+        status = server.db_manager.is_connected()
+    except (OSError, socket.error) as exc:
+        raise_service_unavailable(exc)
+
     return ApiResponse(
         status="ok",
         message="Connected" if status else "Disconnected",
@@ -43,16 +55,35 @@ async def list_tools(server: MCPServer = Depends(get_server)):
 
 @router.post("/tools/call", response_model=ApiResponse)
 async def call_tool(
-    request: ToolCallRequest, 
+    request: ToolCallRequest,
     server: MCPServer = Depends(get_server)
 ):
     try:
-        result = await server.handle_tool_call(request.name, request.arguments)
+        result = await server.handle_tool_call(
+            request.name,
+            request.arguments
+        )
+
         if "error" in result:
-            return ApiResponse(status="error", error=result["error"])
-        return ApiResponse(status="ok", data=result)
+            return ApiResponse(
+                status="error",
+                error=result["error"]
+            )
+
+        return ApiResponse(
+            status="ok",
+            data=result
+        )
+
+    except (OSError, socket.error) as exc:
+        raise_service_unavailable(exc)
+
     except Exception as e:
-        return ApiResponse(status="error", error=str(e))
+        return ApiResponse(
+            status="error",
+            error=str(e)
+        )
+    
 
 @router.post("/index", response_model=ApiResponse)
 async def index_repository(
@@ -60,21 +91,27 @@ async def index_repository(
     background_tasks: BackgroundTasks,
     server: MCPServer = Depends(get_server)
 ):
-    # Map to add_code_to_graph tool
     args = {
         "path": request.path,
         "repo_name": request.repo_name,
         "branch": request.branch,
         "force": request.force
     }
-    
-    # We call handle_tool_call which is async
-    # But add_code_to_graph starts a background job anyway
-    result = await server.handle_tool_call("add_code_to_graph", args)
-    
+
+    try:
+        result = await server.handle_tool_call(
+            "add_code_to_graph",
+            args
+        )
+    except (OSError, socket.error) as exc:
+        raise_service_unavailable(exc)
+
     if "error" in result:
-        raise HTTPException(status_code=400, detail=result["error"])
-        
+        raise HTTPException(
+            status_code=400,
+            detail=result["error"]
+        )
+
     return ApiResponse(
         status="ok",
         message="Indexing job started",
@@ -86,17 +123,35 @@ async def execute_query(
     request: QueryRequest,
     server: MCPServer = Depends(get_server)
 ):
-    result = await server.handle_tool_call("execute_cypher_query", {
-        "cypher_query": request.query,
-        "params": request.params
-    })
-    
+    try:
+        result = await server.handle_tool_call(
+            "execute_cypher_query",
+            {
+                "cypher_query": request.query,
+                "params": request.params,
+            },
+        )
+    except (OSError, socket.error) as exc:
+        raise_service_unavailable(exc)
+
     if "error" in result:
         return ApiResponse(status="error", error=result["error"])
-        
+
     return ApiResponse(status="ok", data=result)
 
 @router.get("/repositories", response_model=ApiResponse)
-async def list_repositories(server: MCPServer = Depends(get_server)):
-    result = await server.handle_tool_call("list_indexed_repositories", {})
-    return ApiResponse(status="ok", data=result)
+async def list_repositories(
+    server: MCPServer = Depends(get_server)
+):
+    try:
+        result = await server.handle_tool_call(
+            "list_indexed_repositories",
+            {}
+        )
+    except (OSError, socket.error) as exc:
+        raise_service_unavailable(exc)
+
+    return ApiResponse(
+        status="ok",
+        data=result
+    )

codegraphcontext/cli/cli_helpers.py

@@ -29,7 +29,13 @@ 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
+from .config_manager import (
+    resolve_context,
+    ResolvedContext,
+    register_repo_in_context,
+    ensure_first_run_bootstrap,
+    ContextNotFoundError,
+)
 
 console = Console()
 
@@ -41,6 +47,9 @@ def _fail_services_init() -> None:
 
 def _kuzu_fallback_path(ctx: ResolvedContext) -> Optional[str]:
     """Derive a KùzuDB directory when falling back from another backend."""
+    runtime = os.getenv("CGC_RUNTIME_DB_PATH")
+    if runtime:
+        return str(Path(runtime).expanduser().resolve())
     if ctx.db_path:
         return str(Path(ctx.db_path).parent / "kuzudb")
     try:
@@ -85,7 +94,11 @@ def _initialize_services(
     """
     ensure_first_run_bootstrap()
     console.print("[dim]Resolving context...[/dim]")
-    ctx = resolve_context(cli_context_flag, cwd=cwd)
+    try:
+        ctx = resolve_context(cli_context_flag, cwd=cwd)
+    except ContextNotFoundError as exc:
+        console.print(f"[bold red]Error:[/bold red] {exc}")
+        raise typer.Exit(code=1)
     
     # Let the user know what context we're operating in
     if ctx.mode == "named":
@@ -120,6 +133,8 @@ def _initialize_services(
         # Check if this is a FalkorDB failure that should trigger a KùzuDB fallback
         from ..core.database_falkordb import FalkorDBUnavailableError
         if isinstance(e, FalkorDBUnavailableError):
+            from ..core import mark_falkordb_unavailable
+            mark_falkordb_unavailable()
             console.print(f"[yellow]⚠ FalkorDB Lite is not functional in this environment: {e}[/yellow]")
             console.print("[cyan]Falling back to KùzuDB for a reliable experience...[/cyan]")
             
@@ -219,8 +234,8 @@ async def _run_index_with_progress(graph_builder: GraphBuilder, path_obj: Path,
                 if job.total_files > 0:
                     progress.update(task_id, total=job.total_files, completed=job.processed_files)
                 
-                # Update the current filename in the UI
-                current_file = job.current_file or ""
+                # Prefer post-processing status over the last parsed file path
+                current_file = job.status_message or job.current_file or ""
                 if len(current_file) > 40:
                     current_file = "..." + current_file[-37:]
                 progress.update(task_id, filename=current_file)
@@ -283,9 +298,10 @@ def index_helper(path: str, context: Optional[str] = None):
         except Exception as e:
             console.print(f"[yellow]Warning: Could not check file count: {e}. Proceeding with indexing...[/yellow]")
 
-    # Auto-register the repo into the named context (auto-creates if needed)
     if context and ctx.mode == "named":
-        register_repo_in_context(context, str(path_obj), auto_create=True)
+        if not register_repo_in_context(context, str(path_obj), auto_create=False):
+            db_manager.close_driver()
+            raise typer.Exit(code=1)
 
     console.print(f"Starting indexing for: {path_obj}")
 
@@ -327,7 +343,7 @@ def add_package_helper(package_name: str, language: str, context: Optional[str]
     if not package_path_str:
         console.print(f"[red]Error: Could not find package '{package_name}' for language '{language}'.[/red]")
         db_manager.close_driver()
-        return
+        raise typer.Exit(code=1)
 
     package_path = Path(package_path_str)
     
@@ -345,6 +361,7 @@ def add_package_helper(package_name: str, language: str, context: Optional[str]
         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}")
+        raise typer.Exit(code=1)
     finally:
         db_manager.close_driver()
 
@@ -406,23 +423,26 @@ def cypher_helper(query: str, context: Optional[str] = None):
         _fail_services_init()
 
     db_manager, _, _, ctx = services
-    
-    # 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']
-    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]")
+
+    from ..utils.cypher_readonly import is_read_only_cypher, read_only_rejection_message
+
+    if not is_read_only_cypher(query):
+        console.print(f"[bold red]Error:[/bold red] {read_only_rejection_message()}")
         db_manager.close_driver()
         raise typer.Exit(code=1)
 
+    backend = getattr(db_manager, "get_backend_type", lambda: "neo4j")()
+    session_kwargs = {"default_access_mode": "READ"} if backend == "neo4j" else {}
+
     try:
-        with db_manager.get_driver().session() as session:
+        with db_manager.get_driver().session(**session_kwargs) as session:
             result = session.run(query)
             records = [record.data() for record in result]
             console.print(json.dumps(records, indent=2))
     except Exception as e:
         console.print(f"[bold red]An error occurred while executing query:[/bold red] {e}")
+        db_manager.close_driver()
+        raise typer.Exit(code=1)
     finally:
         db_manager.close_driver()
 
@@ -430,34 +450,25 @@ def cypher_helper(query: str, context: Optional[str] = None):
 def cypher_helper_visual(query: str, context: Optional[str] = None):
     """Executes a read-only Cypher query and visualizes the results."""
     from .visualizer import visualize_cypher_results
-    
+    from ..utils.cypher_readonly import is_read_only_cypher, read_only_rejection_message
+
     services = _initialize_services(context)
     if not all(services[:3]):
         _fail_services_init()
 
     db_manager, _, _, ctx = services
-    
-    # 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']
-    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]")
+
+    if not is_read_only_cypher(query):
+        console.print(f"[bold red]Error:[/bold red] {read_only_rejection_message()}")
         db_manager.close_driver()
         raise typer.Exit(code=1)
 
     try:
-        with db_manager.get_driver().session() as session:
-            result = session.run(query)
-            records = [record.data() for record in result]
-            
-            if not records:
-                console.print("[yellow]No results to visualize.[/yellow]")
-                return  # finally block will close driver
-            
-            visualize_cypher_results(records, query)
+        visualize_cypher_results(query)
     except Exception as e:
         console.print(f"[bold red]An error occurred while executing query:[/bold red] {e}")
+        db_manager.close_driver()
+        raise typer.Exit(code=1)
     finally:
         db_manager.close_driver()
 
@@ -466,7 +477,12 @@ import uvicorn
 import urllib.parse
 from ..viz.server import run_server, set_db_manager
 
-def visualize_helper(repo_path: Optional[str] = None, port: int = 8000, context: Optional[str] = None):
+def visualize_helper(
+    repo_path: Optional[str] = None,
+    port: int = 8000,
+    context: Optional[str] = None,
+    cypher_query: Optional[str] = None,
+):
     """Generates an interactive visualization using the Playground UI."""
     services = _initialize_services(context)
     if not all(services[:3]):
@@ -537,7 +553,9 @@ def visualize_helper(repo_path: Optional[str] = None, port: int = 8000, context:
     params = {"backend": backend_url}
     if repo_path:
         params["repo_path"] = str(Path(repo_path).resolve())
-    
+    if cypher_query:
+        params["cypher_query"] = cypher_query
+
     query_string = urllib.parse.urlencode(params)
     visualization_url = f"{backend_url}/explore?{query_string}"
     
@@ -558,6 +576,7 @@ def visualize_helper(repo_path: Optional[str] = None, port: int = 8000, context:
         run_server(host="127.0.0.1", port=port, static_dir=str(static_dir))
     except Exception as e:
         console.print(f"[bold red]An error occurred while running the server:[/bold red] {e}")
+        raise typer.Exit(code=1)
     finally:
         db_manager.close_driver()
 
@@ -565,17 +584,18 @@ def visualize_helper(repo_path: Optional[str] = None, port: int = 8000, context:
 def reindex_helper(path: str, context: Optional[str] = None):
     """Force re-index by deleting and rebuilding the repository."""
     time_start = time.time()
-    services = _initialize_services(context)
+    path_obj = Path(path).resolve()
+    index_cwd = path_obj if path_obj.is_dir() else path_obj.parent
+    services = _initialize_services(context, cwd=index_cwd)
     if not all(services[:3]):
         _fail_services_init()
 
     db_manager, graph_builder, code_finder, ctx = services
-    path_obj = Path(path).resolve()
 
     if not path_obj.exists():
         console.print(f"[red]Error: Path does not exist: {path_obj}[/red]")
         db_manager.close_driver()
-        return
+        raise typer.Exit(code=1)
 
     # Check if already indexed
     indexed_repos = code_finder.list_indexed_repositories()
@@ -589,7 +609,7 @@ def reindex_helper(path: str, context: Optional[str] = None):
         except Exception as e:
             console.print(f"[red]Error deleting old index: {e}[/red]")
             db_manager.close_driver()
-            return
+            raise typer.Exit(code=1)
     
     console.print(f"[cyan]Re-indexing: {path_obj}[/cyan]")
     
@@ -627,14 +647,13 @@ def clean_helper(context: Optional[str] = None):
         batch_size = 500
         
         with db_manager.get_driver().session() as session:
-            # Layer-by-layer deletion: iteratively delete nodes that lost
-            # their CONTAINS parent. Each pass peels one layer of the
-            # Repository → File → Class/Function → Variable hierarchy.
+            # Delete nodes with no incoming relationships (true orphans).
+            # Parameters (HAS_PARAMETER), import Modules (IMPORTS), etc. are kept.
             while True:
                 result = session.run("""
                     MATCH (n)
                     WHERE NOT n:Repository
-                      AND NOT ()-[:CONTAINS]->(n)
+                      AND NOT ()-[]->(n)
                     WITH n LIMIT $batch_size
                     DETACH DELETE n
                     RETURN count(n) as deleted
@@ -762,7 +781,7 @@ def stats_helper(path: str = None, context: Optional[str] = None):
         db_manager.close_driver()
 
 
-def watch_helper(path: str, context: Optional[str] = None):
+def watch_helper(path: str, context: Optional[str] = None, use_polling: Optional[bool] = None):
     """Watch a directory for changes and auto-update the graph (blocking mode)."""
     import logging
     from ..core.watcher import CodeWatcher
@@ -782,12 +801,12 @@ def watch_helper(path: str, context: Optional[str] = None):
     if not path_obj.exists():
         console.print(f"[red]Error: Path does not exist: {path_obj}[/red]")
         db_manager.close_driver()
-        return
+        raise typer.Exit(code=1)
     
     if not path_obj.is_dir():
         console.print(f"[red]Error: Path must be a directory: {path_obj}[/red]")
         db_manager.close_driver()
-        return
+        raise typer.Exit(code=1)
 
     console.print(f"[bold cyan]🔍 Watching {path_obj} for changes...[/bold cyan]")
     
@@ -817,7 +836,7 @@ def watch_helper(path: str, context: Optional[str] = None):
     
     # Create watcher instance
     job_manager = JobManager()
-    watcher = CodeWatcher(graph_builder, job_manager)
+    watcher = CodeWatcher(graph_builder, job_manager, use_polling=use_polling)
     
     try:
         # Start the observer thread

codegraphcontext/cli/config_manager.py

@@ -204,11 +204,12 @@ def normalize_config_path(value: str, *, absolute: bool = False, base_dir: Optio
     return str(path_obj)
 
 
-def ensure_config_dir(path: Path = CONFIG_DIR):
+def ensure_config_dir(path: Optional[Path] = None):
     """
     Ensure that the configuration directory exists.
     Creates the directory and a logs subdirectory if they do not already exist.
     """
+    path = path or CONFIG_DIR
     path.mkdir(parents=True, exist_ok=True)
     (path / "logs").mkdir(parents=True, exist_ok=True)
 
@@ -275,11 +276,31 @@ def load_config() -> Dict[str, str]:
     return config
 
 
+def should_apply_project_dotenv() -> bool:
+    """True when cwd-local ``.codegraphcontext/.env`` should merge with global config.
+
+    Skips project env when ``HOME`` is isolated (e.g. E2E) but ``cwd`` is an unrelated
+    checkout, unless ``CGC_LOAD_PROJECT_ENV=1``. Set ``CGC_IGNORE_PROJECT_ENV=1`` to force skip.
+    """
+    if os.getenv("CGC_IGNORE_PROJECT_ENV", "").strip().lower() in ("1", "true", "yes"):
+        return False
+    if os.getenv("CGC_LOAD_PROJECT_ENV", "").strip().lower() in ("1", "true", "yes"):
+        return True
+    try:
+        Path.cwd().resolve().relative_to(Path.home().resolve())
+        return True
+    except ValueError:
+        return False
+
+
 def find_local_env() -> Optional[Path]:
     """
     Find a local .env file by searching current directory and parents.
     Returns the first .env file found, or None.
     """
+    if not should_apply_project_dotenv():
+        return None
+
     current = Path.cwd()
     
     # Search up to 5 levels up
@@ -484,6 +505,11 @@ def get_config_value(key: str) -> Optional[str]:
     return config.get(key)
 
 
+def is_db_deletion_allowed() -> bool:
+    """True when destructive delete/clear operations are permitted."""
+    return str(get_config_value("ALLOW_DB_DELETION") or "false").strip().lower() == "true"
+
+
 def set_config_value(key: str, value: str) -> bool:
     """Set a configuration value. Returns True if successful.
 
@@ -513,7 +539,15 @@ def set_config_value(key: str, value: str) -> bool:
 
 def reset_config():
     """Reset configuration to defaults (preserves database credentials)."""
+    import shutil
+    from datetime import datetime
+
     ensure_config_dir()
+    if CONFIG_FILE.exists():
+        stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+        backup = CONFIG_FILE.with_name(f"{CONFIG_FILE.name}.{stamp}.bak")
+        shutil.copy2(CONFIG_FILE, backup)
+        console.print(f"[dim]Backed up current config to {backup}[/dim]")
     save_config(DEFAULT_CONFIG.copy(), preserve_db_credentials=True)
     console.print("[green]✅ Configuration reset to defaults[/green]")
     console.print("[cyan]Note: Database credentials were preserved[/cyan]")
@@ -538,22 +572,21 @@ def _print_welcome_banner() -> None:
     console.print()
 
 
-def ensure_first_run_bootstrap() -> bool:
+def ensure_first_run_bootstrap(show_welcome: bool = False) -> bool:
     """Run one-time setup for brand-new installs.
 
-    Creates default config files, the global .cgcignore, and prints a
-    welcome banner.  Returns True when bootstrap was performed.
+    Creates default config files and the global .cgcignore silently.
+    Returns True when bootstrap was performed.
     """
     if _FIRST_RUN_MARKER.exists():
         return False
 
     ensure_config_dir()
     ensure_global_cgcignore()
-    # Ensure config.yaml exists (triggers creation with defaults)
     load_context_config()
-    _print_welcome_banner()
+    if show_welcome:
+        _print_welcome_banner()
 
-    # Stamp so we don't repeat
     _FIRST_RUN_MARKER.parent.mkdir(parents=True, exist_ok=True)
     _FIRST_RUN_MARKER.write_text("1")
     return True
@@ -792,6 +825,10 @@ def find_local_cgc_dir(start: Optional[Path] = None) -> Optional[Path]:
     return None
 
 
+class ContextNotFoundError(ValueError):
+    """Raised when --context names an unregistered workspace."""
+
+
 def resolve_context(
     cli_context: Optional[str] = None,
     cwd: Optional[Path] = None,
@@ -811,23 +848,21 @@ def resolve_context(
     # --- 1. Explicit CLI flag ---
     if cli_context:
         ctx = cfg.contexts.get(cli_context)
-        db = ctx.database if ctx else "falkordb"
-        db_path = ctx.db_path if ctx else _default_db_path(cli_context, db)
-        cgcignore = (
-            ctx.cgcignore_path
-            if ctx
-            else str(CONFIG_DIR / "contexts" / cli_context / ".cgcignore")
-        )
+        if ctx is None:
+            raise ContextNotFoundError(
+                f"Context '{cli_context}' is not registered. "
+                f"Create it with: cgc context create {cli_context}"
+            )
         return ResolvedContext(
             mode="named",
             context_name=cli_context,
-            database=db,
-            db_path=db_path,
-            cgcignore_path=cgcignore,
+            database=ctx.database,
+            db_path=ctx.db_path,
+            cgcignore_path=ctx.cgcignore_path,
         )
 
-    # --- 2. Local .codegraphcontext/ in repo ---
-    local_cgc = find_local_cgc_dir(cwd)
+    # --- 2. Local .codegraphcontext/ in repo (per-repo mode only) ---
+    local_cgc = find_local_cgc_dir(cwd) if cfg.mode == "per-repo" else None
     
     # If we are in per-repo mode and no local folder was found, create it in CWD
     if local_cgc is None and cfg.mode == "per-repo":
@@ -864,8 +899,8 @@ def resolve_context(
             is_local=True,
         )
 
-    # --- 2b. Saved workspace mapping (CWD -> child .codegraphcontext/) ---
-    mapping = get_workspace_mapping(cwd)
+    # --- 2b. Saved workspace mapping (per-repo mode only) ---
+    mapping = get_workspace_mapping(cwd) if cfg.mode == "per-repo" else None
     if mapping:
         mapped_ctx_path = Path(mapping["context_path"])
         if mapped_ctx_path.exists() and mapped_ctx_path.is_dir():