codegraph-py 1.0.0__py3-none-any.whl

codegraph/project_config.py

@@ -0,0 +1,191 @@
+"""
+CodeGraph Project Configuration
+
+Manages codegraph.json configuration file reading and writing.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from typing import Any, Dict, List, Optional
+
+from codegraph import errors
+
+CONFIG_FILE = 'codegraph.json'
+
+
+# =============================================================================
+# Config Types
+# =============================================================================
+
+class ProjectConfig:
+    """Project configuration loaded from codegraph.json."""
+
+    def __init__(
+        self,
+        project_root: str,
+        include_patterns: Optional[List[str]] = None,
+        exclude_patterns: Optional[List[str]] = None,
+        include_ignored_patterns: Optional[List[str]] = None,
+        extension_overrides: Optional[Dict[str, str]] = None,
+    ):
+        self.project_root = project_root
+        self.include_patterns = include_patterns or []
+        self.exclude_patterns = exclude_patterns or []
+        self.include_ignored_patterns = include_ignored_patterns or []
+        self.extension_overrides = extension_overrides or {}
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert config to dictionary."""
+        return {
+            'include_patterns': self.include_patterns,
+            'exclude_patterns': self.exclude_patterns,
+            'include_ignored_patterns': self.include_ignored_patterns,
+            'extension_overrides': self.extension_overrides,
+        }
+
+    @classmethod
+    def from_dict(cls, project_root: str, data: Dict[str, Any]) -> ProjectConfig:
+        """Create config from dictionary."""
+        return cls(
+            project_root=project_root,
+            include_patterns=data.get('include_patterns'),
+            exclude_patterns=data.get('exclude_patterns'),
+            include_ignored_patterns=data.get('include_ignored_patterns'),
+            extension_overrides=data.get('extension_overrides'),
+        )
+
+
+# =============================================================================
+# Config File Path
+# =============================================================================
+
+def get_config_path(project_root: str) -> str:
+    """Get the path to the codegraph.json config file."""
+    return os.path.join(project_root, CONFIG_FILE)
+
+
+def config_exists(project_root: str) -> bool:
+    """Check if codegraph.json exists in the project root."""
+    return os.path.isfile(get_config_path(project_root))
+
+
+# =============================================================================
+# Load / Save
+# =============================================================================
+
+def load_config(project_root: str) -> ProjectConfig:
+    """Load the codegraph.json configuration file.
+
+    Args:
+        project_root: Path to the project root directory.
+
+    Returns:
+        ProjectConfig object with the loaded configuration.
+
+    Raises:
+        ConfigError: If the config file cannot be read or parsed.
+    """
+    config_path = get_config_path(project_root)
+
+    if not os.path.isfile(config_path):
+        return ProjectConfig(project_root=project_root)
+
+    try:
+        with open(config_path, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+    except json.JSONDecodeError as e:
+        raise errors.ConfigError(
+            f"Failed to parse {CONFIG_FILE}: {e}"
+        ) from e
+    except OSError as e:
+        raise errors.ConfigError(
+            f"Failed to read {CONFIG_FILE}: {e}"
+        ) from e
+
+    return ProjectConfig.from_dict(project_root, data)
+
+
+def save_config(project_root: str, config: ProjectConfig) -> None:
+    """Save the configuration to codegraph.json.
+
+    Args:
+        project_root: Path to the project root directory.
+        config: ProjectConfig object to save.
+
+    Raises:
+        ConfigError: If the config file cannot be written.
+    """
+    config_path = get_config_path(project_root)
+
+    try:
+        with open(config_path, 'w', encoding='utf-8') as f:
+            json.dump(config.to_dict(), f, indent=2)
+            f.write('\n')
+    except OSError as e:
+        raise errors.ConfigError(
+            f"Failed to write {CONFIG_FILE}: {e}"
+        ) from e
+
+
+# =============================================================================
+# Pattern Loaders
+# =============================================================================
+
+def load_exclude_patterns(project_root: str) -> List[str]:
+    """Load exclude patterns from codegraph.json.
+
+    Args:
+        project_root: Path to the project root directory.
+
+    Returns:
+        List of exclude patterns (glob patterns).
+    """
+    config = load_config(project_root)
+    return config.exclude_patterns
+
+
+def load_include_patterns(project_root: str) -> List[str]:
+    """Load include patterns from codegraph.json.
+
+    Args:
+        project_root: Path to the project root directory.
+
+    Returns:
+        List of include patterns (glob patterns).
+    """
+    config = load_config(project_root)
+    return config.include_patterns
+
+
+def load_include_ignored_patterns(project_root: str) -> List[str]:
+    """Load include_ignored_patterns from codegraph.json.
+
+    These patterns specify files to include even if they would
+    normally be ignored (e.g., node_modules, .git files).
+
+    Args:
+        project_root: Path to the project root directory.
+
+    Returns:
+        List of include_ignored patterns (glob patterns).
+    """
+    config = load_config(project_root)
+    return config.include_ignored_patterns
+
+
+def load_extension_overrides(project_root: str) -> Dict[str, str]:
+    """Load extension overrides from codegraph.json.
+
+    Extension overrides allow mapping file extensions to specific
+    languages (e.g., {".inc": "php"}).
+
+    Args:
+        project_root: Path to the project root directory.
+
+    Returns:
+        Dictionary mapping file extensions to language names.
+    """
+    config = load_config(project_root)
+    return config.extension_overrides

codegraph/resolution/__init__.py

@@ -0,0 +1,337 @@
+"""
+CodeGraph Resolution Module
+
+Reference resolver for connecting symbol usages to their definitions.
+Strategy:
+  Phase 1 — Build import map (module name → project files)
+  Phase 2 — Resolve import edges (module → file)
+  Phase 3 — Resolve call references via import-aware name matching
+  Phase 4 — Fallback to global name matching
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Dict, List, Optional, Set, Tuple, Any, Callable
+from dataclasses import dataclass, field
+
+from codegraph.types import Node, Edge, UnresolvedReference
+from codegraph.db.queries import QueryBuilder
+
+
+@dataclass
+class ResolutionResult:
+    """Result of a resolution pass."""
+    resolved_count: int = 0
+    remaining_count: int = 0
+    edges_created: int = 0
+
+
+@dataclass
+class ImportEntry:
+    """A single import entry for a file."""
+    name: str                    # imported name (e.g. 'join')
+    qualified_name: str          # full qualified (e.g. 'os.path.join')
+    module: str                  # module part (e.g. 'os.path')
+    node_id: str                 # import node ID in graph
+
+
+class ReferenceResolver:
+    """Resolves unresolved references by matching names to defined symbols."""
+
+    def __init__(self, project_root: str, queries: QueryBuilder):
+        self._project_root = project_root
+        self._queries = queries
+        self._initialized = False
+
+        # Import map: {file_path: {imported_name: [ImportEntry, ...]}}
+        self._import_map: Dict[str, Dict[str, List[ImportEntry]]] = {}
+        # Module registry: {module_name: [file_path, ...]}
+        self._module_registry: Dict[str, List[str]] = {}
+        # Node name cache: {name: [Node, ...]} for fast lookup
+        self._name_cache: Dict[str, List[Node]] = {}
+
+    # =========================================================================
+    # Initialization — build import maps & registries
+    # =========================================================================
+
+    def initialize(self) -> None:
+        """Build import maps, module registry, and name cache."""
+        self._build_import_map()
+        self._build_module_registry()
+        self._build_name_cache()
+        self._initialized = True
+
+    def _build_import_map(self) -> None:
+        """Scan all import nodes to build per-file import maps."""
+        import_nodes = self._queries.get_nodes_by_kind('import')
+        for node in import_nodes:
+            fp = node.file_path
+            if fp not in self._import_map:
+                self._import_map[fp] = {}
+
+            name = node.name
+            qualified = node.qualified_name
+
+            # Determine the module part from qualified_name
+            if '.' in qualified:
+                module = qualified.rsplit('.', 1)[0]
+            else:
+                module = qualified
+
+            entry = ImportEntry(
+                name=name,
+                qualified_name=qualified,
+                module=module,
+                node_id=node.id,
+            )
+            self._import_map[fp].setdefault(name, []).append(entry)
+
+    def _build_module_registry(self) -> None:
+        """Build a mapping from module names to project files."""
+        all_files = self._queries.get_all_files()
+
+        for f in all_files:
+            path = f.path
+            # Convert file path to Python module name
+            if path.endswith('.py'):
+                if path.endswith('__init__.py'):
+                    module = path[:-len('__init__.py')].rstrip('/').replace('/', '.')
+                else:
+                    module = path[:-3].replace('/', '.')
+            elif path.endswith('.ts') or path.endswith('.tsx'):
+                module = path.rsplit('.', 1)[0].replace('/', '.')
+            elif path.endswith('.js') or path.endswith('.jsx'):
+                module = path.rsplit('.', 1)[0].replace('/', '.')
+            else:
+                module = path.rsplit('.', 1)[0].replace('/', '.') if '.' in path else path
+
+            self._module_registry.setdefault(module, []).append(path)
+
+            # Also register parent modules
+            parts = module.split('.')
+            for i in range(1, len(parts)):
+                parent = '.'.join(parts[:i])
+                if parent not in self._module_registry:
+                    self._module_registry[parent] = []
+
+    def _build_name_cache(self) -> None:
+        """Build a cache of all nodes by name for fast lookup."""
+        # This is too expensive to load all nodes — use DB queries instead
+        pass
+
+    # =========================================================================
+    # Main resolution pipeline
+    # =========================================================================
+
+    def resolve_all(self, on_progress: Optional[Callable] = None) -> ResolutionResult:
+        """Resolve all pending unresolved references."""
+        if not self._initialized:
+            self.initialize()
+
+        refs = self._queries.get_unresolved_refs()
+        if not refs:
+            return ResolutionResult()
+
+        resolved = 0
+        edges_created = 0
+        total = len(refs)
+
+        for i, ref in enumerate(refs):
+            target_node = self._resolve_single(ref)
+            if target_node:
+                edge_kind = self._ref_kind_to_edge_kind(ref.reference_kind)
+                edge = Edge(
+                    source=ref.from_node_id,
+                    target=target_node.id,
+                    kind=edge_kind,
+                    line=ref.line,
+                    column=ref.column,
+                    provenance='resolved',
+                )
+                self._queries.insert_edge(edge)
+                self._queries._db.execute(
+                    'DELETE FROM unresolved_refs WHERE id = ?', (ref.id,)
+                )
+                resolved += 1
+                edges_created += 1
+
+            if on_progress and (i % 50 == 0 or i == total - 1):
+                on_progress(i + 1, total)
+
+        return ResolutionResult(
+            resolved_count=resolved,
+            remaining_count=self._queries.get_unresolved_refs_count(),
+            edges_created=edges_created,
+        )
+
+    def _resolve_single(self, ref: UnresolvedReference) -> Optional[Node]:
+        """
+        Resolve a single reference using multi-strategy approach.
+
+        Strategies (in order):
+          1. Import-aware: ref's source file imported this name
+          2. Same-file: definition exists in same file as ref
+          3. Global: name matches a node anywhere in project
+          4. Qualified: candidates list has a match
+          5. Module-path: reference_name is a module that maps to a file
+        """
+        name = ref.reference_name
+        source_node = self._queries.get_node_by_id(ref.from_node_id)
+        source_file = source_node.file_path if source_node else None
+
+        # ── Strategy 1: Import-aware resolution ──
+        if source_file and source_file in self._import_map:
+            target = self._resolve_via_imports(name, source_file)
+            if target:
+                return target
+
+        # ── Strategy 2: Same-file resolution ──
+        if source_file:
+            target = self._resolve_in_file(name, source_file)
+            if target:
+                return target
+
+        # ── Strategy 3: Global name matching ──
+        target = self._resolve_global(name, source_file)
+        if target:
+            return target
+
+        # ── Strategy 4: Qualified name candidates ──
+        if ref.candidates:
+            for cname in ref.candidates:
+                matches = self._queries.get_nodes_by_qualified_name(cname)
+                if matches:
+                    return matches[0]
+
+        # ── Strategy 5: Module name → file node ──
+        # If the reference looks like a module name, try to resolve to file
+        if '.' in name or '_' in name:
+            file_paths = self._module_registry.get(name, [])
+            if file_paths:
+                # Find the file node for the first match
+                for fp in file_paths:
+                    file_nodes = self._queries.get_nodes_by_file(fp)
+                    for n in file_nodes:
+                        if n.kind == 'file':
+                            return n
+
+        return None
+
+    # =========================================================================
+    # Resolution strategies
+    # =========================================================================
+
+    def _resolve_via_imports(self, name: str, source_file: str) -> Optional[Node]:
+        """Check if the source file imports 'name' from somewhere, and resolve it."""
+        file_imports = self._import_map.get(source_file, {})
+        entries = file_imports.get(name, [])
+
+        for entry in entries:
+            # Try to find the symbol in the imported module's files
+            mod_paths = self._module_registry.get(entry.module, [])
+            for fp in mod_paths:
+                nodes = self._queries.get_nodes_by_file(fp)
+                for n in nodes:
+                    if n.name == name:
+                        return n
+
+            # Also check the import node's qualified name
+            qname_candidates = self._queries.get_nodes_by_qualified_name(entry.qualified_name)
+            if qname_candidates:
+                return qname_candidates[0]
+
+            # Last resort: look for the module as a file
+            for fp in mod_paths:
+                file_nodes = self._queries.get_nodes_by_file(fp)
+                for n in file_nodes:
+                    if n.kind == 'file':
+                        return n
+
+        return None
+
+    def _resolve_in_file(self, name: str, file_path: str) -> Optional[Node]:
+        """Look for a definition of 'name' in the same file."""
+        nodes = self._queries.get_nodes_by_file(file_path)
+        for n in nodes:
+            if n.name == name and n.kind not in ('file', 'import', 'module'):
+                return n
+        return None
+
+    def _resolve_global(self, name: str, source_file: Optional[str]) -> Optional[Node]:
+        """Global name matching across all indexed nodes."""
+        candidates = self._queries.get_nodes_by_name(name)
+
+        # Filter out file and import nodes
+        real_candidates = [
+            c for c in candidates
+            if c.kind not in ('file', 'import', 'module')
+        ]
+
+        if not real_candidates:
+            return None
+
+        # Prefer same file results
+        if source_file:
+            same_file = [c for c in real_candidates if c.file_path == source_file]
+            if same_file:
+                return same_file[0]
+
+        # Prefer exported/non-private symbols
+        exported = [c for c in real_candidates if c.is_exported or not c.name.startswith('_')]
+        if exported:
+            return exported[0]
+
+        return real_candidates[0]
+
+    # =========================================================================
+    # Post-processing passes (stubs for future enhancements)
+    # =========================================================================
+
+    def resolve_chained_calls_via_conformance(self) -> None:
+        """Second pass: chained calls whose method lives on a supertype."""
+        pass
+
+    def resolve_deferred_this_member_refs(self) -> None:
+        """Resolve 'this.<member>' callback registrations inherited from supertype."""
+        pass
+
+    def run_post_extract(self) -> None:
+        """Run cross-file finalization after extraction."""
+        pass
+
+    # =========================================================================
+    # Helpers
+    # =========================================================================
+
+    def _ref_kind_to_edge_kind(self, ref_kind: str) -> str:
+        """Convert a reference kind to an edge kind."""
+        mapping = {
+            'calls': 'calls',
+            'call': 'calls',
+            'imports': 'imports',
+            'exports': 'exports',
+            'extends': 'extends',
+            'implements': 'implements',
+            'type_of': 'type_of',
+            'returns': 'returns',
+            'instantiates': 'instantiates',
+            'overrides': 'overrides',
+            'decorates': 'decorates',
+            'function_ref': 'references',
+        }
+        return mapping.get(ref_kind, 'references')
+
+    def get_import_map(self) -> Dict[str, Dict[str, List[ImportEntry]]]:
+        """Get the import map (for debugging/inspection)."""
+        return dict(self._import_map)
+
+    def get_module_registry(self) -> Dict[str, List[str]]:
+        """Get the module registry (for debugging/inspection)."""
+        return dict(self._module_registry)
+
+
+def create_resolver(project_root: str, queries: QueryBuilder) -> ReferenceResolver:
+    """Factory function to create a ReferenceResolver."""
+    return ReferenceResolver(project_root, queries)