codegraphcontext 0.4.18__py3-none-any.whl → 0.5.2__py3-none-any.whl

codegraphcontext/api/app.py

@@ -17,7 +17,10 @@ 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=["*"],
     )

codegraphcontext/api/mcp_sse.py

@@ -1,23 +1,27 @@
 # src/codegraphcontext/api/mcp_sse.py
 import json
 import asyncio
-from fastapi import Request
+import logging
+import anyio
+from fastapi import Request, Response
 from mcp.server import Server
 from mcp.server.models import InitializationOptions
 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
+
+logger = logging.getLogger(__name__)
 
 # 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"],
@@ -31,34 +35,71 @@ async def handle_call_tool(name: str, arguments: dict | None) -> list[TextConten
     server = get_server()
     args = arguments or {}
     
-    # 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))]
+    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.
+# Create the SSE transport.
 sse = SseServerTransport("/api/v1/mcp/messages")
 
 async def handle_sse(request: Request):
     """Entry point for the SSE connection."""
-    async with sse.connect_sse(request.scope, request.receive, request._send) as (read_stream, write_stream):
-        await mcp_server.run(
-            read_stream,
-            write_stream,
-            InitializationOptions(
-                server_name="CodeGraphContext",
-                server_version="0.1.0",
-                capabilities=ServerCapabilities(
-                    tools=ToolsCapability(listChanged=False)
+    logger.info("SSE client connected")
+    try:
+        async with sse.connect_sse(request.scope, request.receive, request._send) as (read_stream, write_stream):
+            await mcp_server.run(
+                read_stream,
+                write_stream,
+                InitializationOptions(
+                    server_name="CodeGraphContext",
+                    server_version="0.1.0",
+                    capabilities=ServerCapabilities(
+                        tools=ToolsCapability(listChanged=False)
+                    )
                 )
             )
-        )
+    except anyio.EndOfStream:
+        logger.debug("SSE client disconnected cleanly (stream ended)")
+    except Exception as exc:
+        logger.debug("SSE connection closed: %s", type(exc).__name__)
+    finally:
+        logger.info("SSE client disconnected — handler exited, resources freed")
+
 
 async def handle_messages(request: Request):
-    """Endpoint for receiving messages from the client."""
-    await sse.handle_post_message(request.scope, request.receive, request._send)
+    """Endpoint for receiving messages from the client.
+
+    Uses a buffer framing collector to ensure the full JSON-RPC payload
+    is received before processing. This prevents crashes caused by large
+    responses being split across SSE line boundaries.
+    """
+    # Buffer the complete request body before any parsing occurs.
+    # request.body() accumulates all chunks, preventing partial JSON reads.
+    raw_body = await request.body()
+
+    try:
+        json.loads(raw_body)
+    except json.JSONDecodeError as e:
+        return Response(
+            content=json.dumps({
+                "jsonrpc": "2.0",
+                "error": {
+                    "code": -32700,
+                    "message": f"Parse error: incomplete or malformed JSON-RPC message: {e}"
+                },
+                "id": None
+            }),
+            status_code=400,
+            media_type="application/json"
+        )
+
+    try:
+        await sse.handle_post_message(request.scope, request.receive, request._send)
+    except Exception as exc:
+        logger.debug("Message handler closed: %s", type(exc).__name__)

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

@@ -9,6 +9,7 @@ import time
 import os
 from typing import Optional, List, Dict, Any
 import typer
+from rich import box
 from rich.console import Console
 from rich.table import Table
 from rich.progress import (
@@ -35,6 +36,7 @@ from .config_manager import (
     register_repo_in_context,
     ensure_first_run_bootstrap,
     ContextNotFoundError,
+    is_db_deletion_allowed,
 )
 
 console = Console()
@@ -84,6 +86,42 @@ def _print_call_resolution_diagnostics(graph_builder: GraphBuilder, limit: int =
     console.print(table)
 
 
+def _format_extension_counts(files_by_extension: Dict[str, int]) -> str:
+    if not files_by_extension:
+        return "None"
+    return ", ".join(
+        f"{extension}: {count}" for extension, count in files_by_extension.items()
+    )
+
+
+def _print_index_execution_summary(graph_builder: GraphBuilder) -> None:
+    summary = getattr(graph_builder, "last_index_summary", None)
+    if not summary:
+        return
+
+    table = Table(
+        title="CGC Index Execution Summary",
+        show_header=True,
+        header_style="bold cyan",
+        box=box.ASCII,
+    )
+    table.add_column("Metric", style="cyan", no_wrap=True)
+    table.add_column("Value", style="green", overflow="fold")
+    table.add_row("Total scanned files", str(summary.get("total_scanned_files", 0)))
+    table.add_row(
+        "Files by extension",
+        _format_extension_counts(summary.get("files_by_extension", {})),
+    )
+    table.add_row("Function nodes", str(summary.get("function_nodes", 0)))
+    table.add_row("Class nodes", str(summary.get("class_nodes", 0)))
+    table.add_row("CALLS edges", str(summary.get("call_edges", 0)))
+    table.add_row(
+        "Serialization seconds",
+        f"{summary.get('serialization_seconds', 0.0):.2f}",
+    )
+    console.print(table)
+
+
 def _initialize_services(
     cli_context_flag: Optional[str] = None,
     cwd: Optional[Path] = None,
@@ -314,6 +352,7 @@ def index_helper(path: str, context: Optional[str] = None):
         time_end = time.time()
         elapsed = time_end - time_start
         _print_call_resolution_diagnostics(graph_builder)
+        _print_index_execution_summary(graph_builder)
         console.print(f"[green]Successfully finished indexing: {path} in {elapsed:.2f} seconds[/green]")
         
         # Check if auto-watch is enabled
@@ -362,6 +401,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)
+        _print_index_execution_summary(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}")
@@ -526,6 +566,7 @@ from ..viz.server import run_server, set_db_manager
 
 def visualize_helper(
     repo_path: Optional[str] = None,
+    host: str = "127.0.0.1",
     port: int = 8000,
     context: Optional[str] = None,
     cypher_query: Optional[str] = None,
@@ -620,7 +661,7 @@ def visualize_helper(
     threading.Thread(target=open_browser, daemon=True).start()
     
     try:
-        run_server(host="127.0.0.1", port=port, static_dir=str(static_dir))
+        run_server(host=host, 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)
@@ -665,6 +706,7 @@ def reindex_helper(path: str, context: Optional[str] = None):
         time_end = time.time()
         elapsed = time_end - time_start
         _print_call_resolution_diagnostics(graph_builder)
+        _print_index_execution_summary(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}")
@@ -673,14 +715,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()
@@ -738,6 +798,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:
@@ -746,7 +809,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
@@ -755,20 +818,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")
@@ -828,7 +891,12 @@ def stats_helper(path: str = None, context: Optional[str] = None):
         db_manager.close_driver()
 
 
-def watch_helper(path: str, context: Optional[str] = None, use_polling: Optional[bool] = None):
+def watch_helper(
+    path: str,
+    context: Optional[str] = None,
+    use_polling: Optional[bool] = None,
+    sync_on_start: bool = False,
+):
     """Watch a directory for changes and auto-update the graph (blocking mode)."""
     import logging
     from ..core.watcher import CodeWatcher
@@ -869,7 +937,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:
@@ -891,11 +959,17 @@ 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. Synchronizing current files...")
+            if sync_on_start:
+                console.print("[green]✓[/green] Already indexed. Synchronizing current files...")
+            else:
+                console.print("[green]✓[/green] Already indexed. Watching for future changes only.")
+                console.print(
+                    "[dim]Use 'cgc index --force' or 'cgc watch --sync-on-start' to reconcile existing changes.[/dim]"
+                )
             watcher.watch_directory(
                 str(path_obj),
                 perform_initial_scan=False,
-                sync_on_start=True,
+                sync_on_start=sync_on_start,
                 cgcignore_path=ctx.cgcignore_path,
             )
         else:
@@ -938,7 +1012,7 @@ def watch_helper(path: str, context: Optional[str] = None, use_polling: Optional
     finally:
         watcher.stop()
         db_manager.close_driver()
-        console.print("[green]✓[/green] Watcher stopped. Graph is up to date.")
+        console.print("[green]✓[/green] Watcher stopped.")
 
 
 

codegraphcontext/cli/config_manager.py

@@ -8,12 +8,62 @@ Also manages the context system (config.yaml) alongside the existing .env file.
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Optional, Dict, Any, List
-from rich.console import Console
-from rich.table import Table
+try:
+    from rich.console import Console
+    from rich.table import Table
+    console = Console()
+except Exception:
+    # Lightweight fallback when 'rich' is not installed (tests or minimal envs)
+    class _TableFallback:
+        def __init__(self, show_header=True, header_style=None):
+            self._cols = []
+            self._rows = []
+
+        def add_column(self, name, **_kwargs):
+            self._cols.append(name)
+
+        def add_row(self, *cells):
+            self._rows.append([str(c) for c in cells])
+
+        def __str__(self) -> str:
+            # Simple text table rendering
+            out = []
+            if self._cols:
+                out.append(" | ".join(self._cols))
+                out.append("-" * max(10, len(out[0])))
+            for r in self._rows:
+                out.append(" | ".join(r))
+            return "\n".join(out)
+
+    class _ConsoleFallback:
+        def print(self, *args, **kwargs):
+            # Mimic rich.console.Console.print by delegating to built-in print
+            end = kwargs.get("end", "\n")
+            sep = kwargs.get("sep", " ")
+            for a in args:
+                if isinstance(a, _TableFallback):
+                    built = str(a)
+                    print(built, end=end)
+                else:
+                    print(a, end=end)
+
+    Table = _TableFallback
+    console = _ConsoleFallback()
 import os
 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"
@@ -59,9 +109,14 @@ DEFAULT_CONFIG = {
     # SCIP indexer feature flag (default off — existing Tree-sitter behaviour unchanged)
     "SCIP_INDEXER": "false",
     "SCIP_LANGUAGES": "python,typescript,javascript,go,rust,java,dart,cpp,c,csharp",
+    "SCIP_LOCAL_INDEXER_TIMEOUT_SECONDS": "300",
     "SKIP_EXTERNAL_RESOLUTION": "false",
     # 0 = unlimited; any positive integer caps MCP tool response size.
     "MAX_TOOL_RESPONSE_TOKENS": "0",
+    # 0 = unlimited; any positive integer caps response size in raw characters.
+    # When both MAX_TOOL_RESPONSE_TOKENS and MAX_PROMPT_CHARS are set, the
+    # stricter (smaller) effective character budget wins.
+    "MAX_PROMPT_CHARS": "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": "{}",
@@ -72,6 +127,9 @@ DEFAULT_CONFIG = {
     "CGC_EMBEDDING_BATCH_SIZE": "256",
     # Default fuzzy matching behavior for `cgc find name` (overridable per-command with --fuzzy/--no-fuzzy)
     "FUZZY_SEARCH": "true",
+    # Default LLM model names used for graph queries when no value is explicitly configured
+    "OPENAI_MODEL": "gpt-4o",
+    "ANTHROPIC_MODEL": "claude-3-5-sonnet-20241022",
 }
 
 # Configuration key descriptions
@@ -100,8 +158,10 @@ CONFIG_DESCRIPTIONS = {
     "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,javascript,go,rust,java,dart,cpp,c,csharp)",
+    "SCIP_LOCAL_INDEXER_TIMEOUT_SECONDS": "Timeout in seconds for the local SCIP indexer subprocess (default 300). Raise it for large repositories whose indexer runs longer than 5 minutes; a value <= 0 or non-numeric falls back to 300.",
     "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.",
+    "MAX_PROMPT_CHARS": "Maximum characters per MCP tool response (0 = unlimited). When set alongside MAX_TOOL_RESPONSE_TOKENS the stricter limit wins. Truncated payloads receive a visible [CGC] notice and a stdout warning is emitted.",
     "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": (
@@ -138,6 +198,16 @@ CONFIG_DESCRIPTIONS = {
         "Enable fuzzy matching by default for `cgc find name` (true|false). "
         "Per-invocation overrides are available via --fuzzy / --no-fuzzy."
     ),
+    "OPENAI_MODEL": (
+        "Default OpenAI model used for graph queries. "
+        "Requires OPENAI_API_KEY environment variable. "
+        "Default: gpt-4o"
+    ),
+    "ANTHROPIC_MODEL": (
+        "Default Anthropic model used for graph queries. "
+        "Requires ANTHROPIC_API_KEY environment variable. "
+        "Default: claude-3-5-sonnet-20241022"
+    ),
 }
 
 # Valid values for each config key
@@ -197,6 +267,25 @@ coverage/
 """
 
 
+def resolve_model_name(provider: str, configured_value: Optional[str] = None) -> str:
+    """Get the model it should use for an LLM provider.
+
+    If the user configured a model, it uses that. Otherwise, it falls back to the default
+    model for the provider (like OPENAI_MODEL or ANTHROPIC_MODEL).
+
+    Args:
+        provider: The name of the provider, like "openai" or "anthropic" (case-insensitive).
+        configured_value: The model name from the user's config, if they set one.
+
+    Returns:
+        The model name it should use, or an empty string if it doesn't know the provider.
+    """
+    if configured_value and configured_value.strip():
+        return configured_value.strip()
+    key = f"{provider.upper()}_MODEL"
+    return DEFAULT_CONFIG.get(key, "")
+
+
 def normalize_config_path(value: str, *, absolute: bool = False, base_dir: Optional[Path] = None) -> str:
     """Normalize config path values.
 
@@ -385,30 +474,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]")
@@ -470,6 +556,14 @@ def validate_config_value(key: str, value: str) -> tuple[bool, Optional[str]]:
         except ValueError:
             return False, "MAX_TOOL_RESPONSE_TOKENS must be an integer (0 = unlimited)"
 
+    if key == "MAX_PROMPT_CHARS":
+        try:
+            limit = int(value)
+            if limit < 0:
+                return False, "MAX_PROMPT_CHARS must be 0 (unlimited) or a positive integer"
+        except ValueError:
+            return False, "MAX_PROMPT_CHARS must be an integer (0 = unlimited)"
+
     if key == "TOOL_RESULT_LIMITS":
         import json as _json
         try:
@@ -717,10 +811,17 @@ def _default_global_db_path(database: str) -> str:
 
     New layout: ``~/.codegraphcontext/global/db/<backend>/``
     For backward-compat, we check:
-    1. FALKORDB_PATH in config (if database is falkordb)
-    2. Legacy flat path
-    3. New layout default
+    1. CGC_RUNTIME_DB_PATH environment variable (highest priority — works for all DBs)
+    2. FALKORDB_PATH in config (if database is falkordb)
+    3. Legacy flat path
+    4. New layout default
     """
+    # Generic env var override — highest priority for any backend.
+    # Useful for relocating the global DB to a path that avoids platform-specific
+    # encoding issues (e.g. non-ASCII characters in the Windows user profile path).
+    env_override = os.environ.get("CGC_RUNTIME_DB_PATH")
+    if env_override:
+        return env_override
     if database == "falkordb":
         custom_path = load_config().get("FALKORDB_PATH")
         if custom_path:
@@ -804,8 +905,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]")
 
@@ -887,10 +990,15 @@ def resolve_context(
 
         inherited_db = load_config().get("DEFAULT_DATABASE", "falkordb")
 
-        # Copy global .env into local context for easy per-repo tweaking
+        # 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")
+        _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():
@@ -905,7 +1013,11 @@ def resolve_context(
     if local_cgc is not None:
         # Read local config.yaml if present
         local_yaml = local_cgc / "config.yaml"
-        local_db = load_config().get("DEFAULT_DATABASE", "falkordb")
+        local_db = (
+            os.environ.get("CGC_RUNTIME_DB_TYPE")
+            or os.environ.get("DEFAULT_DATABASE")
+            or load_config().get("DEFAULT_DATABASE", "falkordb")
+        )
         if local_yaml.exists():
             try:
                 with open(local_yaml, encoding="utf-8") as f:
@@ -1172,8 +1284,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]")