shotgun-sh 0.2.29.dev2__py3-none-any.whl → 0.6.1.dev1__py3-none-any.whl

shotgun/codebase/core/ingestor.py

@@ -1,80 +1,73 @@
 """Kuzu graph ingestor for building code knowledge graphs."""
 
+from __future__ import annotations
+
 import asyncio
 import hashlib
+import multiprocessing
 import os
 import time
 import uuid
 from collections import defaultdict
-from collections.abc import Callable
+from collections.abc import Callable, Generator
+from contextlib import contextmanager
 from pathlib import Path
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 import aiofiles
-import kuzu
 from tree_sitter import Node, Parser, QueryCursor
 
-from shotgun.codebase.core.language_config import LANGUAGE_CONFIGS, get_language_config
+from shotgun.codebase.core.call_resolution import calculate_callee_confidence
+from shotgun.codebase.core.gitignore import GitignoreManager
+from shotgun.codebase.core.kuzu_compat import get_kuzu
+from shotgun.codebase.core.metrics_collector import MetricsCollector
+from shotgun.codebase.core.metrics_types import (
+    FileInfo,
+    IndexingPhase,
+    ParallelExecutionResult,
+)
+from shotgun.codebase.core.parallel_executor import ParallelExecutor
+from shotgun.codebase.core.work_distributor import WorkDistributor, get_worker_count
+from shotgun.codebase.models import (
+    IgnoreReason,
+    IndexingStats,
+    IndexProgress,
+    NodeLabel,
+    ProgressPhase,
+    RelationshipType,
+)
+from shotgun.posthog_telemetry import track_event
+from shotgun.settings import settings
+
+if TYPE_CHECKING:
+    import real_ladybug as kuzu
+
+from shotgun.codebase.core.language_config import (
+    LANGUAGE_CONFIGS,
+    get_all_ignore_directories,
+    get_language_config,
+    is_path_ignored,
+    should_ignore_directory,
+)
 from shotgun.codebase.core.parser_loader import load_parsers
 from shotgun.logging_config import get_logger
 
 logger = get_logger(__name__)
 
+# For backwards compatibility, expose IGNORE_PATTERNS from this module
+IGNORE_PATTERNS = get_all_ignore_directories()
 
-# Directories that should never be traversed during indexing
-BASE_IGNORE_DIRECTORIES = {
-    ".git",
-    "venv",
-    ".venv",
-    "__pycache__",
-    ".eggs",
-    ".pytest_cache",
-    ".mypy_cache",
-    ".ruff_cache",
-    ".claude",
-    ".idea",
-    ".vscode",
-}
-
-# Well-known build output directories to skip when determining source files
-BUILD_ARTIFACT_DIRECTORIES = {
-    "node_modules",
-    ".next",
-    ".nuxt",
-    ".vite",
-    ".yarn",
-    ".svelte-kit",
-    ".output",
-    ".turbo",
-    ".parcel-cache",
-    ".vercel",
-    ".serverless",
-    "build",
-    "dist",
-    "out",
-    "tmp",
-    "coverage",
-}
-
-# Default ignore patterns combines base directories and build artifacts
-IGNORE_PATTERNS = BASE_IGNORE_DIRECTORIES | BUILD_ARTIFACT_DIRECTORIES
-
-# Directory prefixes that should always be ignored
-IGNORED_DIRECTORY_PREFIXES = (".",)
-
-
-def should_ignore_directory(name: str, ignore_patterns: set[str] | None = None) -> bool:
-    """Return True if the directory name should be ignored."""
-    patterns = IGNORE_PATTERNS if ignore_patterns is None else ignore_patterns
-    if name in patterns:
-        return True
-    return name.startswith(IGNORED_DIRECTORY_PREFIXES)
-
-
-def is_path_ignored(path: Path, ignore_patterns: set[str] | None = None) -> bool:
-    """Return True if any part of the path should be ignored."""
-    patterns = IGNORE_PATTERNS if ignore_patterns is None else ignore_patterns
-    return any(should_ignore_directory(part, patterns) for part in path.parts)
+# Explicit re-exports for type checkers
+__all__ = [
+    "IGNORE_PATTERNS",
+    "LANGUAGE_CONFIGS",
+    "Ingestor",
+    "SimpleGraphBuilder",
+    "get_all_ignore_directories",
+    "get_language_config",
+    "is_path_ignored",
+    "should_ignore_directory",
+]
 
 
 class Ingestor:
@@ -87,6 +80,8 @@ class Ingestor:
             tuple[str, str, Any, str, str, str, Any, dict[str, Any] | None]
         ] = []
         self.batch_size = 1000
+        # Track seen primary keys to avoid O(n²) duplicate checking
+        self._seen_node_keys: set[tuple[str, str]] = set()
 
     def create_schema(self) -> None:
         """Create the graph schema in Kuzu."""
@@ -159,10 +154,13 @@ class Ingestor:
 
     def ensure_node_batch(self, label: str, properties: dict[str, Any]) -> None:
         """Add a node to the buffer for batch insertion."""
-        # Check for duplicates based on primary key
+        # Check for duplicates based on primary key using O(1) set lookup
         primary_key = self._get_primary_key(label, properties)
-        if primary_key and self._is_duplicate_node(label, primary_key):
-            return
+        if primary_key:
+            key = (label, primary_key)
+            if key in self._seen_node_keys:
+                return
+            self._seen_node_keys.add(key)
 
         self.node_buffer.append((label, properties))
 
@@ -176,29 +174,26 @@ class Ingestor:
 
     def _get_primary_key_field(self, label: str) -> str | None:
         """Get the primary key field name for a node type."""
-        if label == "Project":
+        if label == NodeLabel.PROJECT:
             return "name"
-        elif label in ["Package", "Module", "Class", "Function", "Method"]:
+        elif label in [
+            NodeLabel.PACKAGE,
+            NodeLabel.MODULE,
+            NodeLabel.CLASS,
+            NodeLabel.FUNCTION,
+            NodeLabel.METHOD,
+        ]:
             return "qualified_name"
-        elif label in ["Folder", "File"]:
+        elif label in [NodeLabel.FOLDER, NodeLabel.FILE]:
             return "path"
-        elif label == "FileMetadata":
+        elif label == NodeLabel.FILE_METADATA:
             return "filepath"
-        elif label == "ExternalPackage":
+        elif label == NodeLabel.EXTERNAL_PACKAGE:
             return "name"
-        elif label == "DeletionLog":
+        elif label == NodeLabel.DELETION_LOG:
             return "id"
         return None
 
-    def _is_duplicate_node(self, label: str, primary_key: str) -> bool:
-        """Check if a node with the given primary key already exists in the buffer."""
-        for buffered_label, buffered_props in self.node_buffer:
-            if buffered_label == label:
-                buffered_key = self._get_primary_key(buffered_label, buffered_props)
-                if buffered_key == primary_key:
-                    return True
-        return False
-
     def flush_nodes(
         self,
         progress_callback: Callable[[int, int], None] | None = None,
@@ -272,6 +267,7 @@ class Ingestor:
             logger.info(f"  {label}: {count}")
 
         self.node_buffer.clear()
+        self._seen_node_keys.clear()
 
     def ensure_relationship_batch(
         self,
@@ -410,45 +406,46 @@ class Ingestor:
     ) -> str | None:
         """Determine the actual relationship table name based on source and target."""
         # Mapping of relationship types and from_labels to table names
-        table_mapping = {
-            "CONTAINS_PACKAGE": {
-                "Project": "CONTAINS_PACKAGE",
-                "Package": "CONTAINS_PACKAGE_PKG",
-                "Folder": "CONTAINS_PACKAGE_FOLDER",
+        # Keys use enum values for type-safe comparisons
+        table_mapping: dict[str, dict[str, str]] = {
+            RelationshipType.CONTAINS_PACKAGE: {
+                NodeLabel.PROJECT: "CONTAINS_PACKAGE",
+                NodeLabel.PACKAGE: "CONTAINS_PACKAGE_PKG",
+                NodeLabel.FOLDER: "CONTAINS_PACKAGE_FOLDER",
             },
-            "CONTAINS_FOLDER": {
-                "Project": "CONTAINS_FOLDER",
-                "Package": "CONTAINS_FOLDER_PKG",
-                "Folder": "CONTAINS_FOLDER_FOLDER",
+            RelationshipType.CONTAINS_FOLDER: {
+                NodeLabel.PROJECT: "CONTAINS_FOLDER",
+                NodeLabel.PACKAGE: "CONTAINS_FOLDER_PKG",
+                NodeLabel.FOLDER: "CONTAINS_FOLDER_FOLDER",
             },
-            "CONTAINS_FILE": {
-                "Project": "CONTAINS_FILE",
-                "Package": "CONTAINS_FILE_PKG",
-                "Folder": "CONTAINS_FILE_FOLDER",
+            RelationshipType.CONTAINS_FILE: {
+                NodeLabel.PROJECT: "CONTAINS_FILE",
+                NodeLabel.PACKAGE: "CONTAINS_FILE_PKG",
+                NodeLabel.FOLDER: "CONTAINS_FILE_FOLDER",
             },
-            "CONTAINS_MODULE": {
-                "Project": "CONTAINS_MODULE",
-                "Package": "CONTAINS_MODULE_PKG",
-                "Folder": "CONTAINS_MODULE_FOLDER",
+            RelationshipType.CONTAINS_MODULE: {
+                NodeLabel.PROJECT: "CONTAINS_MODULE",
+                NodeLabel.PACKAGE: "CONTAINS_MODULE_PKG",
+                NodeLabel.FOLDER: "CONTAINS_MODULE_FOLDER",
             },
         }
 
         if rel_type in table_mapping:
             return table_mapping[rel_type].get(from_label)
-        elif rel_type == "DEFINES":
-            if to_label == "Function":
-                return "DEFINES_FUNC"
+        elif rel_type == RelationshipType.DEFINES:
+            if to_label == NodeLabel.FUNCTION:
+                return RelationshipType.DEFINES_FUNC
             else:
-                return "DEFINES"
-        elif rel_type == "CALLS":
-            if from_label == "Function" and to_label == "Function":
-                return "CALLS"
-            elif from_label == "Function" and to_label == "Method":
-                return "CALLS_FM"
-            elif from_label == "Method" and to_label == "Function":
-                return "CALLS_MF"
-            elif from_label == "Method" and to_label == "Method":
-                return "CALLS_MM"
+                return RelationshipType.DEFINES
+        elif rel_type == RelationshipType.CALLS:
+            if from_label == NodeLabel.FUNCTION and to_label == NodeLabel.FUNCTION:
+                return RelationshipType.CALLS
+            elif from_label == NodeLabel.FUNCTION and to_label == NodeLabel.METHOD:
+                return RelationshipType.CALLS_FM
+            elif from_label == NodeLabel.METHOD and to_label == NodeLabel.FUNCTION:
+                return RelationshipType.CALLS_MF
+            elif from_label == NodeLabel.METHOD and to_label == NodeLabel.METHOD:
+                return RelationshipType.CALLS_MM
         elif rel_type.startswith("TRACKS_"):
             # TRACKS relationships already have the correct table name
             return rel_type
@@ -548,10 +545,10 @@ class Ingestor:
 
         # Delete each type of node tracked by this file
         for node_type, rel_type, stat_key in [
-            ("Module", "TRACKS_Module", "modules"),
-            ("Class", "TRACKS_Class", "classes"),
-            ("Function", "TRACKS_Function", "functions"),
-            ("Method", "TRACKS_Method", "methods"),
+            (NodeLabel.MODULE, RelationshipType.TRACKS_MODULE, "modules"),
+            (NodeLabel.CLASS, RelationshipType.TRACKS_CLASS, "classes"),
+            (NodeLabel.FUNCTION, RelationshipType.TRACKS_FUNCTION, "functions"),
+            (NodeLabel.METHOD, RelationshipType.TRACKS_METHOD, "methods"),
         ]:
             try:
                 # First get the nodes to delete (for logging)
@@ -614,6 +611,9 @@ class SimpleGraphBuilder:
         queries: dict[str, Any],
         exclude_patterns: list[str] | None = None,
         progress_callback: Any | None = None,
+        respect_gitignore: bool = True,
+        metrics_collector: MetricsCollector | None = None,
+        enable_parallel: bool = True,
     ):
         self.ingestor = ingestor
         self.repo_path = repo_path
@@ -624,10 +624,26 @@ class SimpleGraphBuilder:
         if exclude_patterns:
             self.ignore_dirs = self.ignore_dirs.union(set(exclude_patterns))
         self.progress_callback = progress_callback
+        self.metrics_collector = metrics_collector
+
+        # Initialize gitignore support
+        self.respect_gitignore = respect_gitignore
+        self.gitignore_manager: GitignoreManager | None = None
+        if respect_gitignore:
+            self.gitignore_manager = GitignoreManager(repo_path)
+            if self.gitignore_manager.stats.patterns_loaded > 0:
+                logger.info(
+                    f"Loaded gitignore patterns - "
+                    f"files: {self.gitignore_manager.stats.gitignore_files_loaded}, "
+                    f"patterns: {self.gitignore_manager.stats.patterns_loaded}"
+                )
 
         # Generate unique session ID for correlating timing events in PostHog
         self._index_session_id = str(uuid.uuid4())[:8]
 
+        # Statistics for tracking what was indexed vs skipped
+        self._index_stats = IndexingStats()
+
         # Caches
         self.structural_elements: dict[Path, str | None] = {}
         self.ast_cache: dict[Path, tuple[Node, str]] = {}
@@ -635,6 +651,153 @@ class SimpleGraphBuilder:
         self.simple_name_lookup: dict[str, set[str]] = defaultdict(set)
         self.class_inheritance: dict[str, list[str]] = {}  # class_qn -> [parent_qns]
 
+        # Parallel execution support
+        self.enable_parallel = enable_parallel
+        self.parallel_executor: ParallelExecutor | None = None
+        self._parallel_mode_active = False  # Track if parallel was used for this run
+        self._worker_count = 0
+        self._init_parallel_executor()
+
+    def _init_parallel_executor(self) -> None:
+        """Initialize parallel executor if conditions are met.
+
+        Conditions for parallel execution:
+        1. enable_parallel=True (constructor parameter)
+        2. settings.indexing.index_parallel is True
+        3. CPU count >= 4
+        """
+        # Check settings override
+        if not settings.indexing.index_parallel:
+            logger.info("Parallel indexing disabled via SHOTGUN_INDEX_PARALLEL=false")
+            return
+
+        if not self.enable_parallel:
+            logger.debug("Parallel indexing disabled via enable_parallel=False")
+            return
+
+        cpu_count = multiprocessing.cpu_count()
+        if cpu_count < 4:
+            logger.info(f"Parallel indexing disabled: CPU count ({cpu_count}) < 4")
+            return
+
+        worker_count = get_worker_count()
+        self.parallel_executor = ParallelExecutor(
+            worker_count=worker_count,
+            metrics_collector=self.metrics_collector,
+        )
+        self._worker_count = worker_count
+        logger.info(f"Parallel indexing enabled with {worker_count} workers")
+
+    def _build_file_infos(
+        self, files_to_process: list[tuple[Path, str]]
+    ) -> list[FileInfo]:
+        """Convert files_to_process list to FileInfo objects for parallel execution.
+
+        Args:
+            files_to_process: List of (filepath, language) tuples
+
+        Returns:
+            List of FileInfo objects ready for WorkDistributor
+        """
+        file_infos: list[FileInfo] = []
+
+        for filepath, language in files_to_process:
+            relative_path = filepath.relative_to(self.repo_path)
+
+            # Compute module_qn (same logic as _process_single_file)
+            if filepath.name == "__init__.py":
+                module_qn = ".".join(
+                    [self.project_name] + list(relative_path.parent.parts)
+                )
+            else:
+                module_qn = ".".join(
+                    [self.project_name] + list(relative_path.with_suffix("").parts)
+                )
+
+            # Get container qualified name from structural elements
+            parent_rel_path = relative_path.parent
+            container_qn = self.structural_elements.get(parent_rel_path)
+
+            try:
+                file_size = filepath.stat().st_size
+            except OSError:
+                file_size = 0
+
+            file_infos.append(
+                FileInfo(
+                    file_path=filepath,
+                    relative_path=relative_path,
+                    language=language,
+                    module_qn=module_qn,
+                    container_qn=container_qn,
+                    file_size_bytes=file_size,
+                )
+            )
+
+        return file_infos
+
+    def _merge_parallel_results(self, result: ParallelExecutionResult) -> None:
+        """Merge parallel execution results into Ingestor buffers and local caches.
+
+        Args:
+            result: ParallelExecutionResult containing all parsed file data
+        """
+        # Merge nodes and direct relationships from each file
+        for file_result in result.results:
+            if not file_result.success:
+                logger.warning(
+                    f"File {file_result.task.file_path} failed: {file_result.error}"
+                )
+                continue
+
+            # Add nodes to buffer
+            for node in file_result.nodes:
+                self.ingestor.ensure_node_batch(node.label, node.properties)
+
+            # Add direct relationships to buffer
+            for rel in file_result.relationships:
+                self.ingestor.ensure_relationship_batch(
+                    rel.from_label,
+                    rel.from_key,
+                    rel.from_value,
+                    rel.rel_type,
+                    rel.to_label,
+                    rel.to_key,
+                    rel.to_value,
+                    rel.properties,
+                )
+
+        # Add resolved relationships (calls, inheritance) from aggregation
+        for rel in result.resolved_relationships:
+            self.ingestor.ensure_relationship_batch(
+                rel.from_label,
+                rel.from_key,
+                rel.from_value,
+                rel.rel_type,
+                rel.to_label,
+                rel.to_key,
+                rel.to_value,
+                rel.properties,
+            )
+
+        # Merge registries into local caches
+        self.function_registry.update(result.function_registry)
+        for name, qns in result.simple_name_lookup.items():
+            for qn in qns:
+                self.simple_name_lookup[name].add(qn)
+
+        # Merge inheritance data for potential future use
+        for file_result in result.results:
+            if file_result.success:
+                for inh in file_result.inheritance_data:
+                    self.class_inheritance[inh.child_class_qn] = inh.parent_simple_names
+
+        logger.info(
+            f"Merged parallel results: {result.successful_files} files, "
+            f"{len(result.function_registry)} registry entries, "
+            f"{len(result.resolved_relationships)} resolved relationships"
+        )
+
     def _report_progress(
         self,
         phase: str,
@@ -648,9 +811,6 @@ class SimpleGraphBuilder:
             return
 
         try:
-            # Import here to avoid circular dependency
-            from shotgun.codebase.models import IndexProgress, ProgressPhase
-
             progress = IndexProgress(
                 phase=ProgressPhase(phase),
                 phase_name=phase_name,
@@ -671,8 +831,6 @@ class SimpleGraphBuilder:
         extra_props: dict[str, Any] | None = None,
     ) -> None:
         """Log timing data to PostHog for analysis."""
-        from shotgun.posthog_telemetry import track_event
-
         properties: dict[str, Any] = {
             "session_id": self._index_session_id,
             "phase": phase,
@@ -692,8 +850,6 @@ class SimpleGraphBuilder:
         total_relationships: int,
     ) -> None:
         """Log indexing summary event to PostHog."""
-        from shotgun.posthog_telemetry import track_event
-
         track_event(
             "codebase_index_completed",
             {
@@ -705,6 +861,24 @@ class SimpleGraphBuilder:
             },
         )
 
+    @contextmanager
+    def _track_phase(
+        self, phase: IndexingPhase, get_items_count: Callable[[], int]
+    ) -> Generator[None, None, None]:
+        """Context manager for tracking phase metrics.
+
+        Args:
+            phase: The indexing phase to track
+            get_items_count: Callable that returns the items processed count
+        """
+        if self.metrics_collector:
+            self.metrics_collector.start_phase(phase)
+        try:
+            yield
+        finally:
+            if self.metrics_collector:
+                self.metrics_collector.end_phase(phase, get_items_count())
+
     async def run(self) -> None:
         """Run the three-pass graph building process."""
         logger.info(f"Building graph for project: {self.project_name}")
@@ -712,17 +886,25 @@ class SimpleGraphBuilder:
         # Pass 1: Structure
         logger.info("Pass 1: Identifying packages and folders...")
         t0 = time.time()
-        self._identify_structure()
+        with self._track_phase(
+            IndexingPhase.STRUCTURE, lambda: self._index_stats.dirs_scanned
+        ):
+            self._identify_structure()
         t1 = time.time()
-        self._log_timing("structure", t1 - t0, len(self.structural_elements))
+        self._log_timing(
+            IndexingPhase.STRUCTURE, t1 - t0, len(self.structural_elements)
+        )
 
         # Pass 2: Definitions
         logger.info("Pass 2: Processing files and extracting definitions...")
         t2 = time.time()
-        await self._process_files()
+        with self._track_phase(
+            IndexingPhase.DEFINITIONS, lambda: self._index_stats.files_processed
+        ):
+            await self._process_files()
         t3 = time.time()
         self._log_timing(
-            "definitions",
+            IndexingPhase.DEFINITIONS,
             t3 - t2,
             len(self.ast_cache),
             {"file_count": len(self.ast_cache)},
@@ -731,52 +913,71 @@ class SimpleGraphBuilder:
         # Pass 3: Relationships
         logger.info("Pass 3: Processing relationships (calls, imports)...")
         t4 = time.time()
-        self._process_relationships()
+        with self._track_phase(
+            IndexingPhase.RELATIONSHIPS, lambda: self._index_stats.files_processed
+        ):
+            self._process_relationships()
         t5 = time.time()
-        self._log_timing("relationships", t5 - t4, len(self.ast_cache))
+        self._log_timing(IndexingPhase.RELATIONSHIPS, t5 - t4, len(self.ast_cache))
 
         # Flush all pending operations
         logger.info("Flushing all data to database...")
-        t6 = time.time()
         node_count = len(self.ingestor.node_buffer)
 
         # Create progress callback for flush_nodes
         def node_progress(current: int, total: int) -> None:
             self._report_progress(
-                "flush_nodes", "Flushing nodes to database", current, total
+                IndexingPhase.FLUSH_NODES, "Flushing nodes to database", current, total
             )
 
-        self.ingestor.flush_nodes(progress_callback=node_progress)
+        t6 = time.time()
+        with self._track_phase(IndexingPhase.FLUSH_NODES, lambda: node_count):
+            self.ingestor.flush_nodes(progress_callback=node_progress)
+        t7 = time.time()
         self._report_progress(
-            "flush_nodes", "Flushing nodes to database", node_count, node_count, True
+            IndexingPhase.FLUSH_NODES,
+            "Flushing nodes to database",
+            node_count,
+            node_count,
+            True,
+        )
+        self._log_timing(
+            IndexingPhase.FLUSH_NODES, t7 - t6, node_count, {"node_count": node_count}
         )
-        t7 = time.time()
-        self._log_timing("flush_nodes", t7 - t6, node_count, {"node_count": node_count})
 
         rel_count = len(self.ingestor.relationship_buffer)
 
         # Create progress callback for flush_relationships
         def rel_progress(current: int, total: int) -> None:
             self._report_progress(
-                "flush_relationships",
+                IndexingPhase.FLUSH_RELATIONSHIPS,
                 "Flushing relationships to database",
                 current,
                 total,
             )
 
-        self.ingestor.flush_relationships(progress_callback=rel_progress)
+        t8_start = time.time()
+        with self._track_phase(IndexingPhase.FLUSH_RELATIONSHIPS, lambda: rel_count):
+            self.ingestor.flush_relationships(progress_callback=rel_progress)
+        t8 = time.time()
         self._report_progress(
-            "flush_relationships",
+            IndexingPhase.FLUSH_RELATIONSHIPS,
             "Flushing relationships to database",
             rel_count,
             rel_count,
             True,
         )
-        t8 = time.time()
         self._log_timing(
-            "flush_relationships", t8 - t7, rel_count, {"relationship_count": rel_count}
+            IndexingPhase.FLUSH_RELATIONSHIPS,
+            t8 - t8_start,
+            rel_count,
+            {"relationship_count": rel_count},
         )
 
+        # Update metrics collector with totals
+        if self.metrics_collector:
+            self.metrics_collector.set_totals(node_count, rel_count)
+
         # Track summary event with totals (no PII - only numeric metadata)
         total_duration = t8 - t0
         self._log_summary(
@@ -786,15 +987,79 @@ class SimpleGraphBuilder:
             total_relationships=rel_count,
         )
 
+        # Log final indexing statistics
+        logger.info("=== Indexing Statistics ===")
+        logger.info(f"  Directories scanned: {self._index_stats.dirs_scanned}")
+        logger.info(
+            f"  Directories ignored (hardcoded patterns): {self._index_stats.dirs_ignored_hardcoded}"
+        )
+        logger.info(
+            f"  Directories ignored (gitignore): {self._index_stats.dirs_ignored_gitignore}"
+        )
+        logger.info(f"  Files scanned: {self._index_stats.files_scanned}")
+        logger.info(
+            f"  Files ignored (hardcoded patterns): {self._index_stats.files_ignored_hardcoded}"
+        )
+        logger.info(
+            f"  Files ignored (gitignore): {self._index_stats.files_ignored_gitignore}"
+        )
+        logger.info(
+            f"  Files ignored (no parser): {self._index_stats.files_ignored_no_parser}"
+        )
+        logger.info(f"  Files processed: {self._index_stats.files_processed}")
+
+        # Log gitignore manager stats if available
+        if self.gitignore_manager:
+            logger.info(f"  {self.gitignore_manager.get_stats_summary()}")
+
         logger.info("Graph building complete!")
 
+    def _should_ignore_directory(
+        self, dir_path: Path, dir_name: str
+    ) -> tuple[bool, IgnoreReason | None]:
+        """Check if a directory should be ignored.
+
+        Args:
+            dir_path: Full path to the directory
+            dir_name: Name of the directory
+
+        Returns:
+            Tuple of (should_ignore, reason)
+        """
+        # Check hardcoded patterns first (fastest)
+        if should_ignore_directory(dir_name, self.ignore_dirs):
+            return True, IgnoreReason.HARDCODED
+
+        # Check gitignore patterns
+        if self.gitignore_manager:
+            try:
+                relative_path = dir_path.relative_to(self.repo_path)
+                if self.gitignore_manager.is_directory_ignored(relative_path):
+                    return True, IgnoreReason.GITIGNORE
+            except ValueError:
+                pass
+
+        return False, None
+
     def _identify_structure(self) -> None:
         """First pass: Walk directory to find packages and folders."""
         dir_count = 0
         for root_str, dirs, _ in os.walk(self.repo_path, topdown=True):
-            dirs[:] = [
-                d for d in dirs if not should_ignore_directory(d, self.ignore_dirs)
-            ]
+            # Filter directories - modifying dirs in-place affects os.walk traversal
+            filtered_dirs = []
+            for d in dirs:
+                dir_path = Path(root_str) / d
+                should_ignore, reason = self._should_ignore_directory(dir_path, d)
+                if should_ignore:
+                    if reason == IgnoreReason.HARDCODED:
+                        self._index_stats.dirs_ignored_hardcoded += 1
+                    elif reason == IgnoreReason.GITIGNORE:
+                        self._index_stats.dirs_ignored_gitignore += 1
+                else:
+                    filtered_dirs.append(d)
+                    self._index_stats.dirs_scanned += 1
+
+            dirs[:] = filtered_dirs
             root = Path(root_str)
             relative_root = root.relative_to(self.repo_path)
 
@@ -831,7 +1096,7 @@ class SimpleGraphBuilder:
                 # Create package
                 package_qn = ".".join([self.project_name] + list(relative_root.parts))
                 self.ingestor.ensure_node_batch(
-                    "Package",
+                    NodeLabel.PACKAGE,
                     {
                         "qualified_name": package_qn,
                         "name": relative_root.name,
@@ -843,22 +1108,22 @@ class SimpleGraphBuilder:
                 if parent_container_qn:
                     # Parent is a package
                     self.ingestor.ensure_relationship_batch(
-                        "Package",
+                        NodeLabel.PACKAGE,
                         "qualified_name",
                         parent_container_qn,
-                        "CONTAINS_PACKAGE",
-                        "Package",
+                        RelationshipType.CONTAINS_PACKAGE,
+                        NodeLabel.PACKAGE,
                         "qualified_name",
                         package_qn,
                     )
                 else:
                     # Parent is project root
                     self.ingestor.ensure_relationship_batch(
-                        "Project",
+                        NodeLabel.PROJECT,
                         "name",
                         self.project_name,
-                        "CONTAINS_PACKAGE",
-                        "Package",
+                        RelationshipType.CONTAINS_PACKAGE,
+                        NodeLabel.PACKAGE,
                         "qualified_name",
                         package_qn,
                     )
@@ -867,7 +1132,7 @@ class SimpleGraphBuilder:
             else:
                 # Create folder
                 self.ingestor.ensure_node_batch(
-                    "Folder",
+                    NodeLabel.FOLDER,
                     {
                         "path": str(relative_root).replace(os.sep, "/"),
                         "name": relative_root.name,
@@ -878,33 +1143,33 @@ class SimpleGraphBuilder:
                 if parent_container_qn:
                     # Parent is a package
                     self.ingestor.ensure_relationship_batch(
-                        "Package",
+                        NodeLabel.PACKAGE,
                         "qualified_name",
                         parent_container_qn,
-                        "CONTAINS_FOLDER",
-                        "Folder",
+                        RelationshipType.CONTAINS_FOLDER,
+                        NodeLabel.FOLDER,
                         "path",
                         str(relative_root).replace(os.sep, "/"),
                     )
                 elif parent_rel_path == Path("."):
                     # Parent is project root
                     self.ingestor.ensure_relationship_batch(
-                        "Project",
+                        NodeLabel.PROJECT,
                         "name",
                         self.project_name,
-                        "CONTAINS_FOLDER",
-                        "Folder",
+                        RelationshipType.CONTAINS_FOLDER,
+                        NodeLabel.FOLDER,
                         "path",
                         str(relative_root).replace(os.sep, "/"),
                     )
                 else:
                     # Parent is another folder
                     self.ingestor.ensure_relationship_batch(
-                        "Folder",
+                        NodeLabel.FOLDER,
                         "path",
                         str(parent_rel_path).replace(os.sep, "/"),
-                        "CONTAINS_FOLDER",
-                        "Folder",
+                        RelationshipType.CONTAINS_FOLDER,
+                        NodeLabel.FOLDER,
                         "path",
                         str(relative_root).replace(os.sep, "/"),
                     )
@@ -919,62 +1184,195 @@ class SimpleGraphBuilder:
             phase_complete=True,
         )
 
+    def _should_ignore_file(self, filepath: Path) -> tuple[bool, IgnoreReason | None]:
+        """Check if a file should be ignored.
+
+        Args:
+            filepath: Full path to the file
+
+        Returns:
+            Tuple of (should_ignore, reason)
+        """
+        # Check hardcoded directory patterns in path
+        if is_path_ignored(filepath, self.ignore_dirs):
+            return True, IgnoreReason.HARDCODED
+
+        # Check gitignore patterns
+        if self.gitignore_manager:
+            try:
+                relative_path = filepath.relative_to(self.repo_path)
+                if self.gitignore_manager.is_ignored(relative_path):
+                    return True, IgnoreReason.GITIGNORE
+            except ValueError:
+                pass
+
+        return False, None
+
     async def _process_files(self) -> None:
         """Second pass: Process files and extract definitions."""
-        # First pass: Count total files
+        # First pass: Count total files (respecting all ignore patterns)
         total_files = 0
-        for root_str, _, files in os.walk(self.repo_path):
+        files_to_process: list[tuple[Path, str]] = []
+
+        for root_str, dirs, files in os.walk(self.repo_path, topdown=True):
             root = Path(root_str)
 
-            # Skip ignored directories
-            if is_path_ignored(root, self.ignore_dirs):
-                continue
+            # Filter directories in-place to prevent os.walk from descending
+            filtered_dirs = []
+            for d in dirs:
+                dir_path = root / d
+                should_ignore, _ = self._should_ignore_directory(dir_path, d)
+                if not should_ignore:
+                    filtered_dirs.append(d)
+            dirs[:] = filtered_dirs
 
             for filename in files:
                 filepath = root / filename
+                self._index_stats.files_scanned += 1
+
+                # Check if file should be ignored
+                should_ignore, reason = self._should_ignore_file(filepath)
+                if should_ignore:
+                    if reason == IgnoreReason.HARDCODED:
+                        self._index_stats.files_ignored_hardcoded += 1
+                    elif reason == IgnoreReason.GITIGNORE:
+                        self._index_stats.files_ignored_gitignore += 1
+                    continue
+
+                # Check if this is a supported file
                 ext = filepath.suffix
                 lang_config = get_language_config(ext)
 
                 if lang_config and lang_config.name in self.parsers:
+                    files_to_process.append((filepath, lang_config.name))
                     total_files += 1
+                else:
+                    self._index_stats.files_ignored_no_parser += 1
 
-        # Second pass: Process files with progress reporting
-        file_count = 0
-        for root_str, _, files in os.walk(self.repo_path):
-            root = Path(root_str)
+        # Log what we're about to process
+        logger.info(
+            f"Index statistics: "
+            f"scanned {self._index_stats.files_scanned} files, "
+            f"processing {total_files}, "
+            f"skipped {self._index_stats.files_ignored_hardcoded} (hardcoded), "
+            f"{self._index_stats.files_ignored_gitignore} (gitignore), "
+            f"{self._index_stats.files_ignored_no_parser} (no parser)"
+        )
 
-            # Skip ignored directories
-            if is_path_ignored(root, self.ignore_dirs):
-                continue
+        # Decide on parallel vs sequential execution
+        # Use parallel if executor available and enough files to benefit
+        if self.parallel_executor and total_files >= 10:
+            await self._process_files_parallel(files_to_process, total_files)
+        else:
+            await self._process_files_sequential(files_to_process, total_files)
 
-            for filename in files:
-                filepath = root / filename
+    async def _process_files_parallel(
+        self, files_to_process: list[tuple[Path, str]], total_files: int
+    ) -> None:
+        """Process files using parallel execution.
 
-                # Check if this is a supported file
-                ext = filepath.suffix
-                lang_config = get_language_config(ext)
+        Args:
+            files_to_process: List of (filepath, language) tuples
+            total_files: Total number of files to process
+        """
+        logger.info(f"Using parallel execution with {self._worker_count} workers")
+        self._parallel_mode_active = True
 
-                if lang_config and lang_config.name in self.parsers:
-                    await self._process_single_file(filepath, lang_config.name)
-                    file_count += 1
+        try:
+            # Build FileInfo objects for WorkDistributor
+            file_infos = self._build_file_infos(files_to_process)
+
+            # Create work batches using WorkDistributor
+            distributor = WorkDistributor(worker_count=self._worker_count)
+            batches = distributor.create_batches(file_infos)
+
+            logger.info(f"Created {len(batches)} batches for {len(file_infos)} files")
 
-                    # Report progress after each file
+            # Track progress for UI
+            files_completed = 0
+
+            def parallel_progress(completed_batches: int, total_batches: int) -> None:
+                nonlocal files_completed
+                # Estimate files completed based on batch progress
+                if total_batches > 0:
+                    estimated = int((completed_batches / total_batches) * total_files)
+                    files_completed = estimated
                     self._report_progress(
                         "definitions",
-                        "Processing files and extracting definitions",
-                        file_count,
+                        f"Processing files (Parallel, {self._worker_count} workers)",
+                        files_completed,
                         total_files,
                     )
 
-                    if file_count % 100 == 0:
-                        logger.info(f"  Processed {file_count}/{total_files} files...")
+            # Execute in parallel - run blocking executor in thread pool
+            loop = asyncio.get_event_loop()
+            result = await loop.run_in_executor(
+                None,
+                lambda: self.parallel_executor.execute(batches, parallel_progress),  # type: ignore[union-attr]
+            )
+
+            # Merge results into Ingestor buffers and local caches
+            self._merge_parallel_results(result)
+
+            # Update stats
+            self._index_stats.files_processed = result.successful_files
+
+            # Report phase completion
+            self._report_progress(
+                "definitions",
+                f"Processing files (Parallel, {self._worker_count} workers)",
+                result.successful_files,
+                total_files,
+                phase_complete=True,
+            )
+
+            logger.info(
+                f"Parallel processing complete: {result.successful_files}/{total_files} "
+                f"files, {result.failed_files} failures"
+            )
+
+        except Exception as e:
+            logger.warning(
+                f"Parallel execution failed: {e}. Falling back to sequential."
+            )
+            self._parallel_mode_active = False
+            await self._process_files_sequential(files_to_process, total_files)
+
+    async def _process_files_sequential(
+        self, files_to_process: list[tuple[Path, str]], total_files: int
+    ) -> None:
+        """Process files using sequential execution (original behavior).
+
+        Args:
+            files_to_process: List of (filepath, language) tuples
+            total_files: Total number of files to process
+        """
+        logger.info("Using sequential execution")
+        self._parallel_mode_active = False
+
+        file_count = 0
+        for filepath, language in files_to_process:
+            await self._process_single_file(filepath, language)
+            file_count += 1
+            self._index_stats.files_processed += 1
+
+            # Report progress after each file
+            self._report_progress(
+                "definitions",
+                "Processing files (Sequential)",
+                file_count,
+                total_files,
+            )
+
+            if file_count % 100 == 0:
+                logger.info(f"  Processed {file_count}/{total_files} files...")
 
         logger.info(f"  Total files processed: {file_count}/{total_files}")
 
         # Report phase completion
         self._report_progress(
             "definitions",
-            "Processing files and extracting definitions",
+            "Processing files (Sequential)",
             file_count,
             total_files,
             phase_complete=True,
@@ -987,7 +1385,7 @@ class SimpleGraphBuilder:
 
         # Create File node
         self.ingestor.ensure_node_batch(
-            "File",
+            NodeLabel.FILE,
             {
                 "path": relative_path_str,
                 "name": filepath.name,
@@ -1000,21 +1398,21 @@ class SimpleGraphBuilder:
         if parent_rel_path == Path("."):
             # File in project root
             self.ingestor.ensure_relationship_batch(
-                "Project",
+                NodeLabel.PROJECT,
                 "name",
                 self.project_name,
-                "CONTAINS_FILE",
-                "File",
+                RelationshipType.CONTAINS_FILE,
+                NodeLabel.FILE,
                 "path",
                 relative_path_str,
             )
         else:
             self.ingestor.ensure_relationship_batch(
-                "Folder",
+                NodeLabel.FOLDER,
                 "path",
                 str(parent_rel_path).replace(os.sep, "/"),
-                "CONTAINS_FILE",
-                "File",
+                RelationshipType.CONTAINS_FILE,
+                NodeLabel.FILE,
                 "path",
                 relative_path_str,
             )
@@ -1043,7 +1441,7 @@ class SimpleGraphBuilder:
 
             current_time = int(time.time())
             self.ingestor.ensure_node_batch(
-                "Module",
+                NodeLabel.MODULE,
                 {
                     "qualified_name": module_qn,
                     "name": filepath.stem,
@@ -1058,33 +1456,33 @@ class SimpleGraphBuilder:
             if parent_container:
                 # Parent is a package
                 self.ingestor.ensure_relationship_batch(
-                    "Package",
+                    NodeLabel.PACKAGE,
                     "qualified_name",
                     parent_container,
-                    "CONTAINS_MODULE",
-                    "Module",
+                    RelationshipType.CONTAINS_MODULE,
+                    NodeLabel.MODULE,
                     "qualified_name",
                     module_qn,
                 )
             elif parent_rel_path == Path("."):
                 # Parent is project root
                 self.ingestor.ensure_relationship_batch(
-                    "Project",
+                    NodeLabel.PROJECT,
                     "name",
                     self.project_name,
-                    "CONTAINS_MODULE",
-                    "Module",
+                    RelationshipType.CONTAINS_MODULE,
+                    NodeLabel.MODULE,
                     "qualified_name",
                     module_qn,
                 )
             else:
                 # Parent is a folder
                 self.ingestor.ensure_relationship_batch(
-                    "Folder",
+                    NodeLabel.FOLDER,
                     "path",
                     str(parent_rel_path).replace(os.sep, "/"),
-                    "CONTAINS_MODULE",
-                    "Module",
+                    RelationshipType.CONTAINS_MODULE,
+                    NodeLabel.MODULE,
                     "qualified_name",
                     module_qn,
                 )
@@ -1098,7 +1496,7 @@ class SimpleGraphBuilder:
 
             # Track module
             self.ingestor.ensure_tracks_relationship(
-                relative_path_str, "Module", module_qn
+                relative_path_str, NodeLabel.MODULE, module_qn
             )
 
             # Extract definitions
@@ -1142,7 +1540,7 @@ class SimpleGraphBuilder:
 
                     current_time = int(time.time())
                     self.ingestor.ensure_node_batch(
-                        "Class",
+                        NodeLabel.CLASS,
                         {
                             "qualified_name": class_qn,
                             "name": class_name,
@@ -1156,26 +1554,23 @@ class SimpleGraphBuilder:
                     )
 
                     # Create DEFINES relationship
-                    logger.debug(
-                        f"Creating DEFINES relationship: Module({module_qn}) -> Class({class_qn})"
-                    )
                     self.ingestor.ensure_relationship_batch(
-                        "Module",
+                        NodeLabel.MODULE,
                         "qualified_name",
                         module_qn,
-                        "DEFINES",
-                        "Class",
+                        RelationshipType.DEFINES,
+                        NodeLabel.CLASS,
                         "qualified_name",
                         class_qn,
                     )
 
                     # Track class
                     self.ingestor.ensure_tracks_relationship(
-                        relative_path_str, "Class", class_qn
+                        relative_path_str, NodeLabel.CLASS, class_qn
                     )
 
                     # Register for lookup
-                    self.function_registry[class_qn] = "Class"
+                    self.function_registry[class_qn] = NodeLabel.CLASS
                     self.simple_name_lookup[class_name].add(class_qn)
 
                     # Extract inheritance
@@ -1187,7 +1582,6 @@ class SimpleGraphBuilder:
         if "function_query" in lang_queries:
             cursor = QueryCursor(lang_queries["function_query"])
             matches = list(cursor.matches(root_node))
-            logger.debug(f"Found {len(matches)} function matches in {filepath}")
             for match in matches:
                 func_node = None
                 func_name = None
@@ -1201,11 +1595,6 @@ class SimpleGraphBuilder:
                             func_name = node.text.decode("utf-8")
 
                 if func_node and func_name:
-                    # Log what we found
-                    logger.debug(
-                        f"Found function: {func_name} at line {func_node.start_point.row + 1}"
-                    )
-
                     # Check if this is a method inside a class
                     parent_class = self._find_parent_class(func_node, module_qn)
 
@@ -1219,7 +1608,7 @@ class SimpleGraphBuilder:
 
                         current_time = int(time.time())
                         self.ingestor.ensure_node_batch(
-                            "Method",
+                            NodeLabel.METHOD,
                             {
                                 "qualified_name": method_qn,
                                 "name": func_name,
@@ -1234,22 +1623,22 @@ class SimpleGraphBuilder:
 
                         # Create DEFINES_METHOD relationship
                         self.ingestor.ensure_relationship_batch(
-                            "Class",
+                            NodeLabel.CLASS,
                             "qualified_name",
                             parent_class,
-                            "DEFINES_METHOD",
-                            "Method",
+                            RelationshipType.DEFINES_METHOD,
+                            NodeLabel.METHOD,
                             "qualified_name",
                             method_qn,
                         )
 
                         # Track method
                         self.ingestor.ensure_tracks_relationship(
-                            relative_path_str, "Method", method_qn
+                            relative_path_str, NodeLabel.METHOD, method_qn
                         )
 
                         # Register for lookup
-                        self.function_registry[method_qn] = "Method"
+                        self.function_registry[method_qn] = NodeLabel.METHOD
                         self.simple_name_lookup[func_name].add(method_qn)
                     else:
                         # This is a standalone function
@@ -1261,7 +1650,7 @@ class SimpleGraphBuilder:
 
                         current_time = int(time.time())
                         self.ingestor.ensure_node_batch(
-                            "Function",
+                            NodeLabel.FUNCTION,
                             {
                                 "qualified_name": func_qn,
                                 "name": func_name,
@@ -1276,22 +1665,22 @@ class SimpleGraphBuilder:
 
                         # Create DEFINES relationship
                         self.ingestor.ensure_relationship_batch(
-                            "Module",
+                            NodeLabel.MODULE,
                             "qualified_name",
                             module_qn,
-                            "DEFINES_FUNC",
-                            "Function",
+                            RelationshipType.DEFINES_FUNC,
+                            NodeLabel.FUNCTION,
                             "qualified_name",
                             func_qn,
                         )
 
                         # Track function
                         self.ingestor.ensure_tracks_relationship(
-                            relative_path_str, "Function", func_qn
+                            relative_path_str, NodeLabel.FUNCTION, func_qn
                         )
 
                         # Register for lookup
-                        self.function_registry[func_qn] = "Function"
+                        self.function_registry[func_qn] = NodeLabel.FUNCTION
                         self.simple_name_lookup[func_name].add(func_qn)
 
     def _extract_decorators(self, node: Node, language: str) -> list[str]:
@@ -1407,6 +1796,25 @@ class SimpleGraphBuilder:
 
     def _process_relationships(self) -> None:
         """Third pass: Process function calls and imports."""
+        # If parallel mode was used, relationships are already resolved
+        # by ParallelExecutor during the definitions phase
+        if self._parallel_mode_active:
+            logger.info(
+                "Skipping relationship processing "
+                "(already resolved during parallel execution)"
+            )
+            # Report progress as complete for UI consistency
+            total = len(self.function_registry)
+            self._report_progress(
+                "relationships",
+                "Relationships resolved during parallel execution",
+                total,
+                total,
+                phase_complete=True,
+            )
+            return
+
+        # Sequential mode - process relationships normally
         # Process inheritance relationships first
         self._process_inheritance()
 
@@ -1418,18 +1826,10 @@ class SimpleGraphBuilder:
             f"Simple name lookup has {len(self.simple_name_lookup)} unique names"
         )
 
-        # Log some examples from simple_name_lookup
-        if self.simple_name_lookup:
-            example_names = list(self.simple_name_lookup.keys())[:5]
-            for name in example_names:
-                logger.debug(
-                    f"  Example: '{name}' -> {list(self.simple_name_lookup[name])[:3]}"
-                )
-
         file_count = 0
         for filepath, (root_node, language) in self.ast_cache.items():
             self._process_calls(filepath, root_node, language)
-            # NOTE: Add import processing. wtf does this mean?
+            # TODO(future): Add import statement processing for IMPORTS relationships
 
             file_count += 1
             # Report progress after each file
@@ -1459,17 +1859,14 @@ class SimpleGraphBuilder:
                 if parent_qn in self.function_registry:
                     # Create INHERITS relationship
                     self.ingestor.ensure_relationship_batch(
-                        "Class",
+                        NodeLabel.CLASS,
                         "qualified_name",
                         child_qn,
-                        "INHERITS",
-                        "Class",
+                        RelationshipType.INHERITS,
+                        NodeLabel.CLASS,
                         "qualified_name",
                         parent_qn,
                     )
-                    logger.debug(
-                        f"  Created inheritance: {child_qn} INHERITS {parent_qn}"
-                    )
                 else:
                     # Try to find parent by simple name lookup
                     parent_simple_name = parent_qn.split(".")[-1]
@@ -1481,21 +1878,14 @@ class SimpleGraphBuilder:
                     if len(possible_parents) == 1:
                         actual_parent_qn = list(possible_parents)[0]
                         self.ingestor.ensure_relationship_batch(
-                            "Class",
+                            NodeLabel.CLASS,
                             "qualified_name",
                             child_qn,
-                            "INHERITS",
-                            "Class",
+                            RelationshipType.INHERITS,
+                            NodeLabel.CLASS,
                             "qualified_name",
                             actual_parent_qn,
                         )
-                        logger.debug(
-                            f"  Created inheritance: {child_qn} INHERITS {actual_parent_qn}"
-                        )
-                    else:
-                        logger.debug(
-                            f"  Could not resolve parent class: {parent_qn} for {child_qn}"
-                        )
 
     def _process_calls(self, filepath: Path, root_node: Node, language: str) -> None:
         """Process function calls in a file."""
@@ -1516,7 +1906,6 @@ class SimpleGraphBuilder:
         # Find all call expressions
         cursor = QueryCursor(lang_queries["call_query"])
         matches = list(cursor.matches(root_node))
-        logger.debug(f"Found {len(matches)} call matches in {filepath}")
         for match in matches:
             call_node = None
 
@@ -1555,36 +1944,23 @@ class SimpleGraphBuilder:
                         break
 
         if not callee_name:
-            logger.debug(
-                f"  Could not extract callee name from call at line {call_node.start_point[0]}"
-            )
             return
 
-        logger.debug(f"  Processing call to {callee_name} (object: {object_name})")
-
         # Find caller function
         caller_qn = self._find_containing_function(call_node, module_qn)
         if not caller_qn:
-            logger.debug(
-                f"  Could not find containing function for call at line {call_node.start_point[0]}"
-            )
             return
 
         # Get all possible callees
         possible_callees = self.simple_name_lookup.get(callee_name, set())
         if not possible_callees:
-            logger.debug(f"  No functions found with name: {callee_name}")
             return
 
-        logger.debug(
-            f"  Found {len(possible_callees)} possible callees for {callee_name}"
-        )
-
         # Calculate confidence scores for each possible callee
         scored_callees = []
         for possible_qn in possible_callees:
-            score = self._calculate_callee_confidence(
-                caller_qn, possible_qn, module_qn, object_name
+            score = calculate_callee_confidence(
+                caller_qn, possible_qn, module_qn, object_name, self.simple_name_lookup
             )
             scored_callees.append((possible_qn, score))
 
@@ -1610,93 +1986,6 @@ class SimpleGraphBuilder:
                 callee_qn,
             )
 
-            # Log with confidence information
-            alternatives = len(scored_callees) - 1
-            logger.info(
-                f"  Created CALLS relationship: {caller_qn} -> {callee_qn} (confidence: {confidence:.2f}, alternatives: {alternatives})"
-            )
-
-            # If multiple alternatives exist with similar confidence, log them
-            if alternatives > 0 and confidence < 1.0:
-                similar_alternatives = [
-                    qn for qn, score in scored_callees[1:4] if score >= confidence * 0.8
-                ]  # Top 3 alternatives  # Within 80% of best score
-                if similar_alternatives:
-                    logger.debug(
-                        f"    Alternative matches: {', '.join(similar_alternatives)}"
-                    )
-        else:
-            logger.warning(
-                f"  Failed to create CALLS relationship - caller_type: {caller_type}, callee_type: {callee_type}"
-            )
-
-    def _calculate_callee_confidence(
-        self, caller_qn: str, callee_qn: str, module_qn: str, object_name: str | None
-    ) -> float:
-        """Calculate confidence score for a potential callee match.
-
-        Args:
-            caller_qn: Qualified name of the calling function
-            callee_qn: Qualified name of the potential callee
-            module_qn: Qualified name of the current module
-            object_name: Object name for method calls (e.g., 'obj' in obj.method())
-
-        Returns:
-            Confidence score between 0.0 and 1.0
-        """
-        score = 0.0
-
-        # 1. Module locality - functions in the same module are most likely
-        if callee_qn.startswith(module_qn + "."):
-            score += 0.5
-
-            # Even higher if in the same class
-            caller_parts = caller_qn.split(".")
-            callee_parts = callee_qn.split(".")
-            if len(caller_parts) >= 3 and len(callee_parts) >= 3:
-                if caller_parts[:-1] == callee_parts[:-1]:  # Same class
-                    score += 0.2
-
-        # 2. Package locality - functions in the same package hierarchy
-        elif "." in module_qn:
-            package = module_qn.rsplit(".", 1)[0]
-            if callee_qn.startswith(package + "."):
-                score += 0.3
-
-        # 3. Object/class match for method calls
-        if object_name:
-            # Check if callee is a method of a class matching the object name
-            callee_parts = callee_qn.split(".")
-            if len(callee_parts) >= 2:
-                # Simple heuristic: check if class name matches object name
-                # (In reality, we'd need type inference for accuracy)
-                class_name = callee_parts[-2]
-                if class_name.lower() == object_name.lower():
-                    score += 0.3
-                elif object_name == "self" and callee_qn.startswith(
-                    caller_qn.rsplit(".", 1)[0]
-                ):
-                    # 'self' refers to the same class
-                    score += 0.4
-
-        # 4. Import presence check (simplified - would need import tracking)
-        # For now, we'll give a small boost to standard library functions
-        if callee_qn.startswith(("builtins.", "typing.", "collections.")):
-            score += 0.1
-
-        # 5. Name similarity for disambiguation
-        # If function names are unique enough, boost confidence
-        possible_count = len(
-            self.simple_name_lookup.get(callee_qn.split(".")[-1], set())
-        )
-        if possible_count == 1:
-            score += 0.2
-        elif possible_count <= 3:
-            score += 0.1
-
-        # Normalize to [0, 1]
-        return min(score, 1.0)
-
     def _find_containing_function(self, node: Node, module_qn: str) -> str | None:
         """Find the containing function/method of a node."""
         current = node.parent
@@ -1760,7 +2049,8 @@ class CodebaseIngestor:
             self.project_name = repo_path_obj.name
 
         try:
-            # Create database
+            # Create database (lazy import kuzu for Windows compatibility)
+            kuzu = get_kuzu()
             logger.info(f"Creating Kuzu database at: {self.db_path}")
             db = kuzu.Database(str(self.db_path))
             conn = kuzu.Connection(db)