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

codegraphcontext/api/app.py

@@ -17,13 +17,21 @@ def create_app() -> FastAPI:
     app.add_middleware(
         CORSMiddleware,
         allow_origins=["*"], # In production, restrict this
-        allow_credentials=True,
+        # Credentials must stay disabled while origins is a wildcard; the
+        # combination is rejected by browsers and would leak cookie-authed
+        # responses to any site.
+        allow_credentials=False,
         allow_methods=["*"],
         allow_headers=["*"],
     )
 
     app.include_router(router, prefix="/api/v1")
 
+    @app.get("/health")
+    async def health():
+        """Liveness probe for load balancers and k8s."""
+        return {"status": "ok"}
+
     # MCP-over-SSE Endpoints
     app.add_api_route("/api/v1/mcp/sse", handle_sse, methods=["GET"])
     app.add_api_route("/api/v1/mcp/messages", handle_messages, methods=["POST"])

codegraphcontext/api/mcp_sse.py

@@ -8,16 +8,17 @@ from mcp.types import Tool, TextContent, ServerCapabilities, ToolsCapability
 from mcp.server.sse import SseServerTransport
 
 from codegraphcontext.api.router import get_server
-from codegraphcontext.tool_definitions import TOOLS
+from codegraphcontext.server import _strip_workspace_prefix, _apply_response_token_limit
 
 # Create the MCP Server instance using the SDK
 mcp_server = Server("CodeGraphContext")
 
 @mcp_server.list_tools()
 async def handle_list_tools() -> list[Tool]:
-    """List available tools."""
+    """List available tools (honors disabledTools from mcp.json)."""
+    server = get_server()
     tools = []
-    for name, defn in TOOLS.items():
+    for name, defn in server.tools.items():
         tools.append(Tool(
             name=name,
             description=defn["description"],
@@ -33,12 +34,16 @@ async def handle_call_tool(name: str, arguments: dict | None) -> list[TextConten
     
     # Execute via the existing handler logic
     result = await server.handle_tool_call(name, args)
+    result = _strip_workspace_prefix(result)
     
     if "error" in result:
         return [TextContent(type="text", text=f"Error: {result['error']}")]
     
-    # Format result as JSON string for the AI
-    return [TextContent(type="text", text=json.dumps(result, indent=2))]
+    # Format result as JSON string for the AI, with the same token budget
+    # the stdio transport applies.
+    response_text = json.dumps(result, indent=2)
+    response_text = _apply_response_token_limit(name, response_text)
+    return [TextContent(type="text", text=response_text)]
 
 # Create the SSE transport. 
 # The messages_url is where the client will POST JSON-RPC messages.

codegraphcontext/api/router.py

@@ -91,12 +91,9 @@ async def index_repository(
     background_tasks: BackgroundTasks,
     server: MCPServer = Depends(get_server)
 ):
-    args = {
-        "path": request.path,
-        "repo_name": request.repo_name,
-        "branch": request.branch,
-        "force": request.force
-    }
+    # The add_code_to_graph handler only understands "path" (and is_dependency);
+    # repo_name/branch/force from the request model are not supported by it.
+    args = {"path": request.path}
 
     try:
         result = await server.handle_tool_call(

codegraphcontext/cli/cli_helpers.py

@@ -35,6 +35,7 @@ from .config_manager import (
     register_repo_in_context,
     ensure_first_run_bootstrap,
     ContextNotFoundError,
+    is_db_deletion_allowed,
 )
 
 console = Console()
@@ -260,6 +261,10 @@ def index_helper(path: str, context: Optional[str] = None):
     """Synchronously indexes a repository in a given context."""
     time_start = time.time()
     path_obj = Path(path).resolve()
+    # Normalize to forward slashes for cross-platform DB consistency.
+    # The graph DB always stores paths via Path.resolve().as_posix(),
+    # so Cypher queries must also use forward slashes on Windows.
+    repo_path_str = path_obj.as_posix()
     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]):
@@ -283,7 +288,7 @@ def index_helper(path: str, context: Optional[str] = None):
             with db_manager.get_driver().session() as session:
                 result = session.run(
                     "MATCH (r:Repository {path: $path})-[:CONTAINS*]->(f:File) RETURN count(DISTINCT f) as file_count",
-                    path=str(path_obj)
+                    path=repo_path_str
                 )
                 record = result.single()
                 file_count = record["file_count"] if record else 0
@@ -415,6 +420,49 @@ def delete_helper(repo_path: str, context: Optional[str] = None):
     finally:
         db_manager.close_driver()
 
+def _print_query_exception(e: Exception, query: str) -> None:
+    """
+    Pretty-print a database query exception, surfacing the raw driver
+    error message so Cypher syntax problems are clearly visible.
+    """
+    import traceback
+
+    error_type = type(e).__name__
+    error_module = type(e).__module__ or ""
+
+    # Neo4j: CypherSyntaxError and other ClientError subclasses carry
+    # a .message and .code attribute with the full server-side detail.
+    if "neo4j" in error_module:
+        code = getattr(e, "code", None)
+        msg = getattr(e, "message", None) or str(e)
+        console.print(f"[bold red]Query Error ({error_type}):[/bold red]")
+        if code:
+            console.print(f"  [yellow]Code:[/yellow] {code}")
+        console.print(f"  [yellow]Message:[/yellow] {msg}")
+
+    # FalkorDB: ResponseError / exceptions in falkordb or redis packages
+    elif "falkordb" in error_module or "redis" in error_module:
+        console.print(f"[bold red]Query Error ({error_type}):[/bold red]")
+        console.print(f"  [yellow]Database message:[/yellow] {e}")
+
+    # KuzuDB: RuntimeError from the kuzu extension
+    # KuzuDB: RuntimeError from the kuzu extension or database_kuzu wrapper
+    elif "kuzu" in error_module or (
+        error_type == "RuntimeError" and "Parser exception" in str(e)
+    ):
+        console.print(f"[bold red]Query Error ({error_type}):[/bold red]")
+        console.print(f"  [yellow]Database message:[/yellow] {e}")
+
+    else:
+        # Fallback: unknown backend — print type + message + traceback
+        console.print(f"[bold red]An error occurred while executing query ({error_type}):[/bold red]")
+        console.print(f"  [yellow]Message:[/yellow] {e}")
+        console.print("[dim]--- Traceback ---[/dim]")
+        console.print(f"[dim]{traceback.format_exc()}[/dim]")
+
+    console.print(f"\n[dim]Failed query:[/dim]")
+    console.print(f"[dim]  {query}[/dim]")
+
 
 def cypher_helper(query: str, context: Optional[str] = None):
     """Executes a read-only Cypher query."""
@@ -440,7 +488,7 @@ def cypher_helper(query: str, context: Optional[str] = None):
             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}")
+        _print_query_exception(e, query)
         db_manager.close_driver()
         raise typer.Exit(code=1)
     finally:
@@ -466,7 +514,7 @@ def cypher_helper_visual(query: str, context: Optional[str] = None):
     try:
         visualize_cypher_results(query)
     except Exception as e:
-        console.print(f"[bold red]An error occurred while executing query:[/bold red] {e}")
+        _print_query_exception(e, query)
         db_manager.close_driver()
         raise typer.Exit(code=1)
     finally:
@@ -626,14 +674,32 @@ def reindex_helper(path: str, context: Optional[str] = None):
         db_manager.close_driver()
 
 
-def update_helper(path: str, context: Optional[str] = None):
-    """Update/refresh index for a path (alias for reindex)."""
+def update_helper(path: str, context: Optional[str] = None, quiet: bool = False):
+    """Update/refresh index for a path (alias for reindex).
+
+    When *quiet* is True (e.g. when invoked from Git hooks with --quiet),
+    Rich console output, including progress rendering, is suppressed.
+    """
+    if quiet:
+        console.quiet = True
+        try:
+            reindex_helper(path, context)
+        finally:
+            console.quiet = False
+        return
     console.print("[cyan]Updating repository index...[/cyan]")
     reindex_helper(path, context)
 
 
 def clean_helper(context: Optional[str] = None):
     """Remove orphaned nodes and relationships from the database."""
+    if not is_db_deletion_allowed():
+        console.print(
+            "[bold red]Error:[/bold red] Database cleanup is disabled. "
+            "Set ALLOW_DB_DELETION=true in config to enable."
+        )
+        raise typer.Exit(code=1)
+
     services = _initialize_services(context)
     if not all(services[:3]):
         _fail_services_init()
@@ -691,6 +757,9 @@ def stats_helper(path: str = None, context: Optional[str] = None):
         if path:
             # Stats for specific repository
             path_obj = Path(path).resolve()
+            # Paths are stored with forward slashes (as_posix) in the graph DB,
+            # so lookups must use the same normalization on Windows too.
+            repo_path_str = path_obj.as_posix()
             console.print(f"[cyan]📊 Statistics for: {path_obj}[/cyan]\n")
             
             with db_manager.get_driver().session() as session:
@@ -699,7 +768,7 @@ def stats_helper(path: str = None, context: Optional[str] = None):
                 MATCH (r:Repository {path: $path})
                 RETURN r
                 """
-                result = session.run(repo_query, path=str(path_obj))
+                result = session.run(repo_query, path=repo_path_str)
                 if not result.single():
                     console.print(f"[red]Repository not found: {path_obj}[/red]")
                     return
@@ -708,20 +777,20 @@ def stats_helper(path: str = None, context: Optional[str] = None):
                 # Get stats using separate queries to handle depth and avoid Cartesian products
                 # 1. Files
                 file_query = "MATCH (r:Repository {path: $path})-[:CONTAINS*]->(f:File) RETURN count(f) as c"
-                file_count = session.run(file_query, path=str(path_obj)).single()["c"]
+                file_count = session.run(file_query, path=repo_path_str).single()["c"]
                 
                 # 2. Functions (including methods in classes)
                 func_query = "MATCH (r:Repository {path: $path})-[:CONTAINS*]->(func:Function) RETURN count(func) as c"
-                func_count = session.run(func_query, path=str(path_obj)).single()["c"]
+                func_count = session.run(func_query, path=repo_path_str).single()["c"]
                 
                 # 3. Classes
                 class_query = "MATCH (r:Repository {path: $path})-[:CONTAINS*]->(c:Class) RETURN count(c) as c"
-                class_count = session.run(class_query, path=str(path_obj)).single()["c"]
+                class_count = session.run(class_query, path=repo_path_str).single()["c"]
                 
                 # 4. Modules (imported) - Note: Module nodes are outside the repo structure usually, connected via IMPORTS
                 # We need to traverse from files to modules
                 module_query = "MATCH (r:Repository {path: $path})-[:CONTAINS*]->(f:File)-[:IMPORTS]->(m:Module) RETURN count(DISTINCT m) as c"
-                module_count = session.run(module_query, path=str(path_obj)).single()["c"]
+                module_count = session.run(module_query, path=repo_path_str).single()["c"]
 
                 table = Table(show_header=True, header_style="bold magenta")
                 table.add_column("Metric", style="cyan")
@@ -822,7 +891,7 @@ def watch_helper(path: str, context: Optional[str] = None, use_polling: Optional
             with code_finder.driver.session() as _s:
                 _r = _s.run(
                     "MATCH (n:File) WHERE n.path STARTS WITH $p RETURN count(n) AS c",
-                    p=str(path_obj) + "/"
+                    p=path_obj.as_posix() + "/"
                 )
                 _count = _r.single()["c"]
             if _count > 100:
@@ -844,10 +913,11 @@ def watch_helper(path: str, context: Optional[str] = None, use_polling: Optional
         
         # Add the directory to watch
         if is_indexed:
-            console.print("[green]✓[/green] Already indexed (no initial scan needed)")
+            console.print("[green]✓[/green] Already indexed. Synchronizing current files...")
             watcher.watch_directory(
                 str(path_obj),
                 perform_initial_scan=False,
+                sync_on_start=True,
                 cgcignore_path=ctx.cgcignore_path,
             )
         else:

codegraphcontext/cli/config_manager.py

@@ -15,6 +15,19 @@ import yaml
 
 console = Console()
 
+
+def _atomic_write_text(path: Path, content: str, *, secure: bool = False) -> None:
+    """Write *content* to *path* atomically (temp file + replace)."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp_path = path.with_suffix(path.suffix + ".tmp")
+    with open(tmp_path, "w", encoding="utf-8") as f:
+        f.write(content)
+        f.flush()
+        os.fsync(f.fileno())
+    os.replace(tmp_path, path)
+    if secure:
+        os.chmod(path, 0o600)
+
 # Configuration file location
 CONFIG_DIR = Path.home() / ".codegraphcontext"
 CONFIG_FILE = CONFIG_DIR / ".env"
@@ -160,6 +173,14 @@ CONFIG_VALIDATORS = {
     "CGC_EMBEDDING_MODEL": ["local", "openai"],
     "FUZZY_SEARCH": ["true", "false"],
 }
+
+SUPPORTED_DATABASES: List[str] = CONFIG_VALIDATORS["DEFAULT_DATABASE"]
+DATABASE_CLI_HELP = (
+    "Database backend ("
+    + "|".join(SUPPORTED_DATABASES)
+    + "). Defaults to DEFAULT_DATABASE from config."
+)
+
 DEFAULT_CGCIGNORE_PATTERNS = """\
 # Default .cgcignore patterns
 # Lines starting with # are comments; blank lines are ignored.
@@ -279,18 +300,25 @@ def load_config() -> Dict[str, str]:
 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.
+    Project env is loaded only in **per-repo** context mode (or when
+    ``CGC_LOAD_PROJECT_ENV=1``). In **global** / **named** mode, ``~/.codegraphcontext/.env``
+    wins so clones with a checked-in ``.codegraphcontext/.env`` do not hijack config.
+
+    Set ``CGC_IGNORE_PROJECT_ENV=1`` to force skip; ``CGC_LOAD_PROJECT_ENV=1`` to force load.
     """
     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
+    cfg = load_context_config()
+    if cfg.mode != "per-repo":
+        return False
     try:
         Path.cwd().resolve().relative_to(Path.home().resolve())
         return True
     except ValueError:
-        return False
+        # Per-repo indexing from /tmp with an isolated HOME (common in E2E/CI).
+        return True
 
 
 def find_local_env() -> Optional[Path]:
@@ -370,30 +398,27 @@ def save_config(config: Dict[str, str], preserve_db_credentials: bool = True):
                 credentials_to_write[key] = config[key]
     
     try:
-        with open(CONFIG_FILE, "w", encoding="utf-8") as f:
-            f.write("# CodeGraphContext Configuration\n")
-            f.write(f"# Location: {CONFIG_FILE}\n\n")
-            
-            # Write database credentials first if they exist
-            if credentials_to_write:
-                f.write("# ===== Database Credentials =====\n")
-                for key in sorted(DATABASE_CREDENTIAL_KEYS):
-                    if key in credentials_to_write:
-                        f.write(f"{key}={credentials_to_write[key]}\n")
-                f.write("\n")
-            
-            # Write configuration settings
-            f.write("# ===== Configuration Settings =====\n")
-            for key, value in sorted(config.items()):
-                # Skip database credentials (already written above)
-                if key in DATABASE_CREDENTIAL_KEYS:
-                    continue
-                    
-                description = CONFIG_DESCRIPTIONS.get(key, "")
-                if description:
-                    f.write(f"# {description}\n")
-                f.write(f"{key}={value}\n\n")
-        
+        lines = [
+            "# CodeGraphContext Configuration",
+            f"# Location: {CONFIG_FILE}",
+            "",
+        ]
+        if credentials_to_write:
+            lines.append("# ===== Database Credentials =====")
+            for key in sorted(DATABASE_CREDENTIAL_KEYS):
+                if key in credentials_to_write:
+                    lines.append(f"{key}={credentials_to_write[key]}")
+            lines.append("")
+        lines.append("# ===== Configuration Settings =====")
+        for key, value in sorted(config.items()):
+            if key in DATABASE_CREDENTIAL_KEYS:
+                continue
+            description = CONFIG_DESCRIPTIONS.get(key, "")
+            if description:
+                lines.append(f"# {description}")
+            lines.append(f"{key}={value}")
+            lines.append("")
+        _atomic_write_text(CONFIG_FILE, "\n".join(lines), secure=True)
         console.print(f"[green]✅ Configuration saved to {CONFIG_FILE}[/green]")
     except Exception as e:
         console.print(f"[red]Error saving config: {e}[/red]")
@@ -789,8 +814,10 @@ def save_context_config(cfg: ContextConfig) -> None:
     }
 
     try:
-        with open(CONTEXT_CONFIG_FILE, "w", encoding="utf-8") as f:
-            yaml.dump(raw, f, default_flow_style=False, sort_keys=False)
+        _atomic_write_text(
+            CONTEXT_CONFIG_FILE,
+            yaml.dump(raw, default_flow_style=False, sort_keys=False),
+        )
     except Exception as e:
         console.print(f"[red]Error saving config.yaml: {e}[/red]")
 
@@ -869,23 +896,38 @@ def resolve_context(
         local_cgc = cwd / ".codegraphcontext"
         local_cgc.mkdir(parents=True, exist_ok=True)
         (local_cgc / "db").mkdir(exist_ok=True)
-        
-        # Copy global .env into local context for easy per-repo tweaking
+
+        inherited_db = load_config().get("DEFAULT_DATABASE", "falkordb")
+
+        # Copy global .env into local context for easy per-repo tweaking.
+        # Guard against the self-copy case: when cwd is the home directory,
+        # local_cgc resolves to CONFIG_DIR itself, so `local_cgc / ".env"` is
+        # CONFIG_FILE. Copying a file onto itself raises shutil.SameFileError,
+        # which crashes resolve_context for any session started from home.
         import shutil
-        if CONFIG_FILE.exists():
-            shutil.copy2(CONFIG_FILE, local_cgc / ".env")
-            
-        console.print(f"[dim]Auto-initialized per-repo context at {local_cgc}[/dim]")
+        _target_env = local_cgc / ".env"
+        if CONFIG_FILE.exists() and _target_env.resolve() != CONFIG_FILE.resolve():
+            shutil.copy2(CONFIG_FILE, _target_env)
+
+        local_yaml = local_cgc / "config.yaml"
+        if not local_yaml.exists():
+            with open(local_yaml, "w", encoding="utf-8") as f:
+                yaml.safe_dump({"database": inherited_db}, f)
+
+        console.print(
+            f"[dim]Auto-initialized per-repo context at {local_cgc} "
+            f"(Database: {inherited_db})[/dim]"
+        )
 
     if local_cgc is not None:
         # Read local config.yaml if present
         local_yaml = local_cgc / "config.yaml"
-        local_db = "falkordb"
+        local_db = load_config().get("DEFAULT_DATABASE", "falkordb")
         if local_yaml.exists():
             try:
                 with open(local_yaml, encoding="utf-8") as f:
                     local_raw = yaml.safe_load(f) or {}
-                local_db = local_raw.get("database", "falkordb")
+                local_db = local_raw.get("database", local_db)
             except Exception:
                 pass
         db_path = str(local_cgc / "db" / local_db)
@@ -1147,8 +1189,10 @@ def _save_workspace_mappings(mappings: Dict[str, Dict[str, str]]) -> None:
             raw = {}
     raw["workspace_mappings"] = mappings
     try:
-        with open(CONTEXT_CONFIG_FILE, "w", encoding="utf-8") as f:
-            yaml.dump(raw, f, default_flow_style=False, sort_keys=False)
+        _atomic_write_text(
+            CONTEXT_CONFIG_FILE,
+            yaml.dump(raw, default_flow_style=False, sort_keys=False),
+        )
     except Exception as e:
         console.print(f"[red]Error saving workspace mappings: {e}[/red]")