graph-dependency-analyzer 0.2.0__py3-none-any.whl

src/domain/entities/dependency_graph.py

@@ -0,0 +1,110 @@
+"""DependencyGraph entities - represent dependency graph structures."""
+from dataclasses import dataclass, field
+
+
+@dataclass
+class DependencyNode:
+    """
+    DependencyNode representing a node in the dependency graph.
+
+    Can represent: Repository, Class, Method, Library, API, Database.
+
+    Attributes:
+        id: Unique identifier for the node
+        node_type: Type of node (REPOSITORY, CLASS, METHOD, LIBRARY, API, DATABASE)
+        properties: Node properties (name, path, version, etc.)
+    """
+    id: str
+    node_type: str
+    properties: dict
+
+
+@dataclass
+class DependencyEdge:
+    """
+    DependencyEdge representing an edge in the dependency graph.
+
+    Can represent: CONTAINS, HAS_METHOD, CALLS, IMPORTS, USES_LIBRARY,
+    CALLS_API, CONNECTS_TO, DEPENDS_ON.
+
+    Attributes:
+        source: Source node ID
+        target: Target node ID
+        edge_type: Type of relationship
+        properties: Edge properties (line number, reason, etc.)
+    """
+    source: str
+    target: str
+    edge_type: str
+    properties: dict = field(default_factory=dict)
+
+
+@dataclass
+class DependencyGraph:
+    """
+    DependencyGraph containing nodes and edges.
+
+    Represents the complete dependency structure of a repository,
+    including internal dependencies (code-to-code) and external
+    dependencies (APIs, databases, libraries).
+
+    Attributes:
+        nodes: List of DependencyNode entities
+        edges: List of DependencyEdge entities
+
+    Business Rules:
+        - Edges always reference nodes that exist in the graph
+        - No duplicate nodes (unique by ID)
+    """
+    nodes: list[DependencyNode] = field(default_factory=list)
+    edges: list[DependencyEdge] = field(default_factory=list)
+
+    def add_node(self, node: DependencyNode) -> None:
+        """
+        Add a node to the graph.
+
+        Args:
+            node: DependencyNode to add
+        """
+        self.nodes.append(node)
+
+    def add_edge(self, edge: DependencyEdge) -> None:
+        """
+        Add an edge to the graph.
+
+        Args:
+            edge: DependencyEdge to add
+        """
+        self.edges.append(edge)
+
+    def get_dependents(self, target: str) -> list[DependencyNode]:
+        """
+        Get all nodes that depend on the target node.
+
+        Returns nodes where there's an edge pointing TO the target.
+        (Who depends on this target?)
+
+        Args:
+            target: Node ID to find dependents for
+
+        Returns:
+            List of DependencyNode that have edges pointing to target
+        """
+        dependent_ids = {edge.source for edge in self.edges if edge.target == target}
+        return [node for node in self.nodes if node.id in dependent_ids]
+
+    def get_dependencies(self, source: str) -> list[DependencyNode]:
+        """
+        Get all dependencies of the source node.
+
+        Returns nodes where there's an edge FROM source pointing to them.
+        (What does this source depend on?)
+
+        Args:
+            source: Node ID to find dependencies for
+
+        Returns:
+            List of DependencyNode that source depends on
+        """
+        dependency_ids = {edge.target for edge in self.edges if edge.source == source}
+        return [node for node in self.nodes if node.id in dependency_ids]

src/domain/entities/repository.py

@@ -0,0 +1,46 @@
+"""Repository entity - represents a Git repository being indexed."""
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+
+
+@dataclass
+class Repository:
+    """
+    Repository entity representing a codebase being indexed.
+
+    Attributes:
+        name: Repository name (e.g., "order-service")
+        path: Absolute path to repository directory
+        language: Primary language (e.g., "java")
+        indexed_at: Timestamp when indexing occurred
+        files: List of CodeFile entities in this repository
+
+    Business Rules:
+        - Repository name must be unique
+        - Path must exist and be accessible
+    """
+    name: str
+    path: Path
+    language: str
+    indexed_at: datetime = field(default_factory=datetime.now)
+    files: list = field(default_factory=list)
+
+    def add_file(self, code_file) -> None:
+        """
+        Add a CodeFile to this repository.
+
+        Args:
+            code_file: CodeFile entity to add
+        """
+        self.files.append(code_file)
+
+    def get_dependency_graph(self):
+        """
+        Get dependency graph for this repository.
+
+        Returns:
+            DependencyGraph with nodes and edges extracted from files
+        """
+        from src.domain.entities.dependency_graph import DependencyGraph
+        return DependencyGraph()

src/domain/exceptions.py

@@ -0,0 +1,36 @@
+"""
+Domain Layer Exceptions (Task 9.3)
+
+Exception hierarchy for domain layer errors.
+"""
+
+
+class DomainException(Exception):
+    """Base exception for domain layer errors."""
+
+    def __init__(self, message: str, details: dict | None = None):
+        """
+        Initialize domain exception.
+
+        Args:
+            message: Human-readable error message
+            details: Optional dict with additional context
+        """
+        super().__init__(message)
+        self.message = message
+        self.details = details or {}
+
+
+class InvalidDependencyError(DomainException):
+    """Invalid dependency detected."""
+    pass
+
+
+class InvalidQualifiedNameError(DomainException):
+    """Invalid qualified name format."""
+    pass
+
+
+class ChunkingError(DomainException):
+    """Error during semantic chunking."""
+    pass

src/domain/repositories/__init__.py

@@ -0,0 +1,22 @@
+"""Domain repository interfaces module."""
+from src.domain.repositories.i_code_parser import ICodeParser, ParseResult
+from src.domain.repositories.i_vector_repository import IVectorRepository, VectorStorageResult
+from src.domain.repositories.i_graph_repository import (
+    IGraphRepository,
+    GraphStorageResult,
+    ImpactAnalysisResult,
+)
+from src.domain.repositories.i_embedding_provider import IEmbeddingProvider
+from src.domain.repositories.i_dependency_extractor import IDependencyExtractor
+
+__all__ = [
+    "ICodeParser",
+    "ParseResult",
+    "IVectorRepository",
+    "VectorStorageResult",
+    "IGraphRepository",
+    "GraphStorageResult",
+    "ImpactAnalysisResult",
+    "IEmbeddingProvider",
+    "IDependencyExtractor",
+]

src/domain/repositories/i_code_parser.py

@@ -0,0 +1,50 @@
+"""ICodeParser interface - contract for AST parsing implementations."""
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Protocol, Any, runtime_checkable
+
+
+@dataclass
+class ParseResult:
+    """
+    ParseResult containing extracted AST structures.
+
+    Attributes:
+        file_path: Path to the parsed file
+        classes: List of extracted class information
+        methods: List of extracted method information
+        imports: List of extracted import statements
+        method_calls: List of extracted method calls
+        string_literals: List of string literals found in code
+    """
+    file_path: Path
+    classes: list[Any] = field(default_factory=list)
+    methods: list[Any] = field(default_factory=list)
+    imports: list[Any] = field(default_factory=list)
+    method_calls: list[Any] = field(default_factory=list)
+    string_literals: list[str] = field(default_factory=list)
+
+
+@runtime_checkable
+class ICodeParser(Protocol):
+    """
+    Interface for code parsers (Tree-sitter, etc.).
+
+    Implementations must parse source code files and extract
+    AST structures like classes, methods, imports, and method calls.
+    """
+
+    def parse_file(self, file_path: Path) -> ParseResult:
+        """
+        Parse a source code file and extract AST structures.
+
+        Args:
+            file_path: Path to source file to parse
+
+        Returns:
+            ParseResult with extracted structures
+
+        Raises:
+            ParseError: If parsing fails
+        """
+        ...

src/domain/repositories/i_dependency_extractor.py

@@ -0,0 +1,35 @@
+"""IDependencyExtractor interface - contract for dependency extraction implementations."""
+from typing import Protocol, runtime_checkable
+
+
+@runtime_checkable
+class IDependencyExtractor(Protocol):
+    """
+    Interface for dependency extractors.
+
+    Implementations must extract dependencies from AST nodes,
+    build files, and configuration files.
+    """
+
+    def extract_dependencies(
+        self,
+        ast_nodes: list,  # list[ASTNode]
+        build_files: dict[str, str],
+        config_files: dict[str, str]
+    ):  # -> DependencyGraph
+        """
+        Extract internal and external dependencies from multiple sources.
+
+        Args:
+            ast_nodes: Parsed AST from source files
+            build_files: Content of pom.xml, build.gradle, etc (filename -> content)
+            config_files: Content of application.properties, .env, etc (filename -> content)
+
+        Returns:
+            DependencyGraph with nodes (classes, methods, libs, APIs, DBs)
+            and edges (calls, imports, uses)
+
+        Raises:
+            DependencyExtractionError: If critical extraction fails
+        """
+        ...

src/domain/repositories/i_embedding_provider.py

@@ -0,0 +1,31 @@
+"""IEmbeddingProvider interface - contract for embedding generation implementations."""
+from typing import Protocol, runtime_checkable
+
+
+@runtime_checkable
+class IEmbeddingProvider(Protocol):
+    """
+    Interface for embedding providers (OpenAI, etc.).
+
+    Implementations must generate embeddings for text chunks.
+    """
+
+    async def embed_batch(
+        self,
+        texts: list[str],
+        batch_size: int = 10
+    ) -> list[list[float]]:
+        """
+        Generate embeddings for batch of texts.
+
+        Args:
+            texts: List of text chunks to embed
+            batch_size: Number of texts per API call (default 10)
+
+        Returns:
+            List of embedding vectors (1536 floats each)
+
+        Raises:
+            EmbeddingProviderError: If API fails after retries
+        """
+        ...

src/domain/repositories/i_graph_repository.py

@@ -0,0 +1,78 @@
+"""IGraphRepository interface - contract for graph storage implementations."""
+from dataclasses import dataclass
+from typing import Protocol, Any, runtime_checkable
+
+
+@dataclass
+class GraphStorageResult:
+    """
+    GraphStorageResult containing storage statistics.
+
+    Attributes:
+        nodes_created: Number of nodes created in graph
+        relationships_created: Number of relationships created
+    """
+    nodes_created: int
+    relationships_created: int
+
+
+@dataclass
+class ImpactAnalysisResult:
+    """
+    ImpactAnalysisResult containing impact analysis query results.
+
+    Attributes:
+        target: Target entity being analyzed (repo, class, API)
+        query_type: Type of analysis performed
+        affected_components: List of affected components
+    """
+    target: str
+    query_type: str
+    affected_components: list[Any]
+
+
+@runtime_checkable
+class IGraphRepository(Protocol):
+    """
+    Interface for graph storage repositories (Neo4j, etc.).
+
+    Implementations must store dependency graphs and support
+    impact analysis queries.
+    """
+
+    async def store_dependency_graph(
+        self,
+        graph,  # DependencyGraph
+        repository_name: str
+    ) -> GraphStorageResult:
+        """
+        Store complete dependency graph in graph database.
+
+        Args:
+            graph: DependencyGraph with nodes and edges
+            repository_name: Name of repository being indexed
+
+        Returns:
+            GraphStorageResult with counts (nodes_created, relationships_created)
+
+        Raises:
+            GraphStorageError: If storage fails
+        """
+        ...
+
+    async def query_impact_analysis(
+        self,
+        query_type: str,
+        params: dict[str, Any]
+    ) -> ImpactAnalysisResult:
+        """
+        Execute impact analysis query.
+
+        Args:
+            query_type: Type of analysis (REPO_DEPENDENTS, CLASS_IMPACT, etc)
+            params: Query parameters (repo_name, class_name, etc)
+
+        Returns:
+            ImpactAnalysisResult with affected components
+        """
+        ...

src/domain/repositories/i_vector_repository.py

@@ -0,0 +1,55 @@
+"""IVectorRepository interface - contract for vector storage implementations."""
+from dataclasses import dataclass
+from typing import Protocol, runtime_checkable
+
+
+@dataclass
+class VectorStorageResult:
+    """
+    VectorStorageResult containing upsert statistics.
+
+    Attributes:
+        points_upserted: Number of vector points upserted
+    """
+    points_upserted: int
+
+
+@runtime_checkable
+class IVectorRepository(Protocol):
+    """
+    Interface for vector storage repositories (Qdrant, etc.).
+
+    Implementations must store embeddings with metadata and
+    support querying unique repositories.
+    """
+
+    async def upsert_batch(
+        self,
+        chunks: list,
+        embeddings: list[list[float]],
+        batch_size: int = 1000
+    ) -> VectorStorageResult:
+        """
+        Upsert batch of embeddings with metadata to vector storage.
+
+        Args:
+            chunks: Code chunks with metadata
+            embeddings: Corresponding embeddings (1536-dim)
+            batch_size: Points per upsert call (default 1000)
+
+        Returns:
+            VectorStorageResult with count of points upserted
+
+        Raises:
+            VectorStorageError: If upsert fails
+        """
+        ...
+
+    async def get_unique_repositories(self) -> list[str]:
+        """
+        Get list of unique repository names indexed.
+
+        Returns:
+            List of repository names
+        """
+        ...

src/domain/services/__init__.py

@@ -0,0 +1,8 @@
+"""Domain services module."""
+from src.domain.services.dependency_extractor import DependencyExtractor
+from src.domain.services.semantic_chunk_builder import SemanticChunkBuilder
+
+__all__ = [
+    "DependencyExtractor",
+    "SemanticChunkBuilder",
+]