codegraphcontext-rust 0.5.5__cp310-cp310-win_amd64.whl

codegraphcontext/core/cgcignore.py

@@ -0,0 +1,118 @@
+from pathlib import Path
+from typing import Iterable, Optional, Tuple
+from pathspec import PathSpec
+
+
+def _resolve_explicit_path(ignore_root: Path, explicit_path: Optional[str]) -> Optional[Path]:
+    """Resolve an explicit .cgcignore path relative to *ignore_root*."""
+    if not explicit_path:
+        return None
+
+    candidate = Path(explicit_path)
+    if not candidate.is_absolute():
+        candidate = (ignore_root / candidate).resolve()
+    return candidate
+
+def parse_cgcignore_lines(lines: Iterable[str]) -> list[str]:
+    """Return valid ignore patterns from raw .cgcignore lines.
+
+    Valid patterns are non-empty lines that do not start with '#'.
+    """
+    patterns: list[str] = []
+    for raw_line in lines:
+        line = raw_line.strip()
+        if not line or line.startswith("#"):
+            continue
+        patterns.append(line)
+    return patterns
+
+
+def find_cgcignore(ignore_root: Path, explicit_path: Optional[str] = None) -> Optional[Path]:
+    """Find a repository-local .cgcignore, with explicit path fallback."""
+
+    # Search parent folders only within the current git worktree. If the
+    # indexed path is outside a git repo (e.g. /tmp test dirs), avoid crawling
+    # up to filesystem-wide locations like /tmp/.cgcignore.
+    git_root: Optional[Path] = None
+    probe = ignore_root
+    while True:
+        if (probe / ".git").exists():
+            git_root = probe
+            break
+        if probe.parent == probe:
+            break
+        probe = probe.parent
+
+    curr = ignore_root
+    while True:
+        candidate = curr / ".cgcignore"
+        if candidate.exists():
+            return candidate
+
+        if git_root is None:
+            return None
+
+        if curr == git_root:
+            break
+
+        curr = curr.parent
+
+    explicit_candidate = _resolve_explicit_path(ignore_root, explicit_path)
+    if explicit_candidate and explicit_candidate.exists():
+        return explicit_candidate
+    return None
+
+def ensure_default_cgcignore(path: Path, default_patterns: list[str]) -> None:
+    """Create a .cgcignore file with default patterns when it does not exist."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    content = "# Auto-generated by CodeGraphContext\n"
+    content += "# Default ignore patterns for binary/media files\n"
+    content += "# Add your own patterns below\n\n"
+    content += "\n".join(default_patterns) + "\n"
+    path.write_text(content, encoding="utf-8")
+
+
+def read_cgcignore_patterns(path: Path, default_patterns: list[str]) -> list[str]:
+    """Read .cgcignore patterns and merge them with defaults.
+
+    Empty lines and comment lines are ignored.
+    """
+    if not path.exists():
+        return list(default_patterns)
+
+    user_patterns = parse_cgcignore_lines(path.read_text(encoding="utf-8").splitlines())
+    # User patterns first so explicit repo rules take precedence.
+    return user_patterns + list(default_patterns)
+
+def build_ignore_spec(
+    ignore_root: Path,
+    default_patterns: list[str],
+    explicit_path: Optional[str] = None,
+) -> Tuple[PathSpec, Optional[Path]]:
+    """Build PathSpec using merged default + user .cgcignore patterns.
+
+    Returns the compiled spec and the discovered/created .cgcignore path.
+    """
+    local_cgcignore_path = find_cgcignore(ignore_root, explicit_path=None)
+    explicit_cgcignore_path = _resolve_explicit_path(ignore_root, explicit_path)
+
+    if local_cgcignore_path is None:
+        local_cgcignore_path = ignore_root / ".cgcignore"
+        ensure_default_cgcignore(local_cgcignore_path, default_patterns)
+
+    merged_user_patterns: list[str] = []
+    merged_user_patterns.extend(
+        parse_cgcignore_lines(local_cgcignore_path.read_text(encoding="utf-8").splitlines())
+    )
+
+    if (
+        explicit_cgcignore_path
+        and explicit_cgcignore_path.exists()
+        and explicit_cgcignore_path != local_cgcignore_path
+    ):
+        merged_user_patterns.extend(
+            parse_cgcignore_lines(explicit_cgcignore_path.read_text(encoding="utf-8").splitlines())
+        )
+
+    all_patterns = merged_user_patterns + list(default_patterns)
+    return PathSpec.from_lines("gitwildmatch", all_patterns), local_cgcignore_path

codegraphcontext/core/database.py

@@ -0,0 +1,273 @@
+# src/codegraphcontext/core/database.py
+"""
+This module provides a thread-safe singleton manager for the Neo4j database connection.
+"""
+import os
+import re
+import threading
+from typing import Optional, Tuple
+from neo4j import GraphDatabase, Driver
+
+from codegraphcontext.utils.debug_log import debug_log, info_logger, error_logger, warning_logger
+
+class Neo4jDriverWrapper:
+    """
+    A simple wrapper around the Neo4j Driver to inject a database name into session() calls.
+    """
+    def __init__(self, driver: Driver, database: str = None):
+        self._driver = driver
+        self._database = database
+
+    def session(self, **kwargs):
+        """Proxy method to get a session from the underlying driver."""
+        if self._database and 'database' not in kwargs:
+            kwargs["database"] = self._database
+        return self._driver.session(**kwargs)
+    
+    def close(self):
+        """Proxy method to close the underlying driver."""
+        self._driver.close()
+
+class DatabaseManager:
+    """
+    Manages the Neo4j database driver as a singleton to ensure only one
+    connection pool is created and shared across the application.
+    
+    This pattern is crucial for performance and resource management in a
+    multi-threaded or asynchronous application.
+    """
+    _instance = None
+    _driver: Optional[Driver] = None
+    _lock = threading.Lock() # Lock to ensure thread-safe initialization. 
+
+    def __new__(cls):
+        """Standard singleton pattern implementation."""
+        if cls._instance is None:
+            with cls._lock:
+                # Double-check locking to prevent race conditions.
+                if cls._instance is None:
+                    cls._instance = super(DatabaseManager, cls).__new__(cls)
+        return cls._instance
+
+    def __init__(self):
+        """
+        Initializes the manager by reading credentials from environment variables.
+        The `_initialized` flag prevents re-initialization on subsequent calls.
+        """
+        if hasattr(self, '_initialized'):
+            return
+
+        self.neo4j_uri = os.getenv('NEO4J_URI')
+        self.neo4j_username = os.getenv('NEO4J_USERNAME', 'neo4j')
+        self.neo4j_password = os.getenv('NEO4J_PASSWORD')
+        self.neo4j_database = os.getenv('NEO4J_DATABASE') # Optional, if not set, will use default database configured in Neo4j
+        self._initialized = True
+
+    def get_driver(self) -> Driver:
+        """
+        Gets the Neo4j driver instance, creating it if it doesn't exist.
+        This method is thread-safe.
+
+        Raises:
+            ValueError: If Neo4j credentials are not set in environment variables.
+
+        Returns:
+            The a wrapper for Neo4j Driver instance.
+        """
+        if self._driver is None:
+            with self._lock:
+                if self._driver is None:
+                    # Ensure all necessary credentials are provided.
+                    if not all([self.neo4j_uri, self.neo4j_username, self.neo4j_password]):
+                        raise ValueError(
+                            "Neo4j credentials must be set via environment variables:\n"
+                            "- NEO4J_URI\n"
+                            "- NEO4J_USERNAME\n"
+                            "- NEO4J_PASSWORD"
+                        )
+                    
+                    #validating the config before creating the driver/attempting connection
+                    is_valid, validation_error = self.validate_config(
+                    self.neo4j_uri, 
+                    self.neo4j_username, 
+                    self.neo4j_password
+                    )
+                    
+                    if not is_valid:
+                        error_logger(f"Configuration validation failed: {validation_error}")
+                        raise ValueError(validation_error)
+
+                    info_logger(f"Creating Neo4j driver connection to {self.neo4j_uri}")
+                    self._driver = GraphDatabase.driver(
+                        self.neo4j_uri,
+                        auth=(self.neo4j_username, self.neo4j_password)
+                    )
+                    # Test the connection immediately to fail fast if credentials are wrong.
+                    try:
+                        with self._driver.session() as session:
+                            session.run("RETURN 1").consume()
+                        info_logger("Neo4j connection established successfully")
+                    except Exception as e:
+                        # Use detailed error messages from test_connection
+                        _, detailed_error = self.test_connection(
+                            self.neo4j_uri,
+                            self.neo4j_username,
+                            self.neo4j_password
+                        )
+                        error_logger(f"Failed to connect to Neo4j: {e}")
+                        if self._driver:
+                            self._driver.close()
+                        self._driver = None
+                        raise
+        return Neo4jDriverWrapper(self._driver, database=self.neo4j_database)
+
+    def close_driver(self):
+        """Closes the Neo4j driver connection if it exists."""
+        if self._driver is not None:
+            with self._lock:
+                if self._driver is not None:
+                    info_logger("Closing Neo4j driver")
+                    self._driver.close()
+                    self._driver = None
+
+    def is_connected(self) -> bool:
+        """Checks if the database connection is currently active."""
+        if self._driver is None:
+            return False
+        try:
+            session_kwargs = {}
+            if self.neo4j_database:
+                session_kwargs['database'] = self.neo4j_database
+            with self._driver.session(**session_kwargs) as session:
+                session.run("RETURN 1").consume()
+            return True
+        except Exception:
+            return False
+    
+    def get_backend_type(self) -> str:
+        """Returns the database backend type."""
+        return 'neo4j'
+
+
+    @staticmethod
+    def validate_config(uri: str, username: str, password: str) -> Tuple[bool, Optional[str]]:
+        """
+        Validates Neo4j configuration parameters.
+        
+        Returns:
+            Tuple[bool, Optional[str]]: (is_valid, error_message)
+        """
+        # Validate URI format
+        # Modified regex to make port optional "(:\\d+)?"
+        uri_pattern = r'^(neo4j|neo4j\+s|neo4j\+ssc|bolt|bolt\+s|bolt\+ssc)://[^:]+(:\d+)?$'
+        if not re.match(uri_pattern, uri):
+            return False, (
+                "Invalid Neo4j URI format.\n"
+                "Expected format: neo4j://host:port or bolt://host:port\n"
+                "Example: neo4j://localhost:7687\n"
+                "Common mistake: Missing 'neo4j://' or 'bolt://' prefix"
+            )
+        
+        # Validate username
+        if not username or len(username.strip()) == 0:
+            return False, (
+                "Username cannot be empty.\n"
+                "Default Neo4j username is 'neo4j'"
+            )
+        
+        # Validate password
+        if not password or len(password.strip()) == 0:
+            return False, (
+                "Password cannot be empty.\n"
+                "Tip: If you just set up Neo4j, use the password you configured during setup"
+            )
+        
+        return True, None
+
+    @staticmethod
+    def test_connection(uri: str, username: str, password: str, database: str=None) -> Tuple[bool, Optional[str]]:
+        """
+        Tests the Neo4j database connection.
+        
+        Returns:
+            Tuple[bool, Optional[str]]: (is_connected, error_message)
+        """
+        try:
+            from neo4j import GraphDatabase
+            import socket
+            
+            # First, test if the host is reachable
+            try:
+                # Extract host and port from URI
+                host_port = uri.split('://')[1]
+                if ':' in host_port:
+                    host = host_port.split(':')[0]
+                    port = int(host_port.split(':')[1])
+                else:
+                    host = host_port
+                    port = 7687 # Default Neo4j port
+                
+                # Test socket connection
+                sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                sock.settimeout(5)
+                result = sock.connect_ex((host, port))
+                sock.close()
+                
+                if result != 0:
+                    return False, (
+                        f"Cannot reach Neo4j server at {host}:{port}\n"
+                        "Troubleshooting:\n"
+                        "  • Is Neo4j running? Check with: docker ps (for Docker)\n"
+                        "  • Is the port correct? Default is 7687\n"
+                        "  • Is there a firewall blocking the connection?\n"
+                        f"  • Try: docker compose up -d (if using Docker)"
+                    )
+            except Exception as e:
+                return False, f"Error parsing URI or checking connectivity: {str(e)}"
+            
+            # Now test Neo4j authentication
+            driver = GraphDatabase.driver(uri, auth=(username, password))
+            
+            session_kwargs = {}
+            if database:
+                session_kwargs['database'] = database # Pass database to session if provided
+            with driver.session(**session_kwargs) as session:
+                result = session.run("RETURN 'Connection successful' as status")
+                result.single()
+            
+            driver.close()
+            return True, None
+            
+        except Exception as e:
+            error_msg = str(e).lower()
+            
+            # Provide specific error messages for common issues
+            if "authentication" in error_msg or "unauthorized" in error_msg:
+                return False, (
+                    "Authentication failed - Invalid username or password\n"
+                    "Troubleshooting:\n"
+                    "  • Default username is 'neo4j'\n"
+                    "  • Did you change the password during initial setup?\n"
+                    "  • If you forgot the password, you may need to reset Neo4j:\n"
+                    "    - Stop: docker compose down\n"
+                    "    - Remove data: docker volume rm <volume_name>\n"
+                    "    - Restart: docker compose up -d"
+                )
+            elif "serviceunAvailable" in error_msg or "failed to establish connection" in error_msg:
+                return False, (
+                    "Neo4j service is not available\n"
+                    "Troubleshooting:\n"
+                    "  • Is Neo4j running? Check: docker ps\n"
+                    "  • Start Neo4j: docker compose up -d\n"
+                    "  • Check logs: docker compose logs neo4j\n"
+                    "  • Wait 30-60 seconds after starting for Neo4j to initialize"
+                )
+            elif "unable to retrieve routing information" in error_msg:
+                return False, (
+                    "Cannot connect to Neo4j routing\n"
+                    "Troubleshooting:\n"
+                    "  • Try using 'bolt://' instead of 'neo4j://' in the URI\n"
+                    "  • Example: bolt://localhost:7687"
+                )
+            else:
+                return False, f"Connection failed: {str(e)}"