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

src/domain/value_objects/__init__.py

@@ -0,0 +1,12 @@
+"""Domain value objects module."""
+from src.domain.value_objects.qualified_name import QualifiedName
+from src.domain.value_objects.dependency_type import DependencyType
+from src.domain.value_objects.chunk_type import ChunkType
+from src.domain.value_objects.node_type import NodeType
+
+__all__ = [
+    "QualifiedName",
+    "DependencyType",
+    "ChunkType",
+    "NodeType",
+]

src/domain/value_objects/chunk_type.py

@@ -0,0 +1,24 @@
+"""ChunkType enum - types of code chunks for embeddings."""
+from enum import Enum
+
+
+class ChunkType(Enum):
+    """
+    ChunkType enum representing types of semantic code chunks.
+
+    Values:
+        METHOD: Complete method with body
+        CLASS: Class declaration with imports (when no methods)
+        IMPORT_BLOCK: Import statements block
+        CONSTRUCTOR: Constructor method
+        FUNCTION: TypeScript/JavaScript function (Task 15.1)
+        HOOK: React hook function (Task 15.1)
+        COMPONENT: React/Angular/Vue component (Task 15.2)
+    """
+    METHOD = "method"
+    CLASS = "class"
+    IMPORT_BLOCK = "import_block"
+    CONSTRUCTOR = "constructor"
+    FUNCTION = "function"
+    HOOK = "hook"
+    COMPONENT = "component"

src/domain/value_objects/dependency_type.py

@@ -0,0 +1,22 @@
+"""DependencyType enum - types of dependencies detected in code."""
+from enum import Enum
+
+
+class DependencyType(Enum):
+    """
+    DependencyType enum representing types of dependencies.
+
+    Values:
+        LIBRARY: Maven/Gradle library dependency (e.g., org.springframework.boot:spring-boot-starter-web)
+        API: External HTTP/HTTPS API endpoint
+        DATABASE: Database connection (JDBC, JPA)
+        MICROSERVICE: Another internal microservice/repository
+        INTERNAL_CLASS: Class in the same repository
+        INTERNAL_METHOD: Method in the same repository
+    """
+    LIBRARY = "library"
+    API = "api"
+    DATABASE = "database"
+    MICROSERVICE = "microservice"
+    INTERNAL_CLASS = "internal_class"
+    INTERNAL_METHOD = "internal_method"

src/domain/value_objects/node_type.py

@@ -0,0 +1,22 @@
+"""NodeType enum - types of AST nodes."""
+from enum import Enum
+
+
+class NodeType(Enum):
+    """
+    NodeType enum representing types of Abstract Syntax Tree nodes.
+
+    Values:
+        CLASS: Class declaration
+        INTERFACE: Interface declaration
+        METHOD: Method declaration
+        CONSTRUCTOR: Constructor declaration
+        IMPORT: Import statement
+        METHOD_CALL: Method invocation/call
+    """
+    CLASS = "class"
+    INTERFACE = "interface"
+    METHOD = "method"
+    CONSTRUCTOR = "constructor"
+    IMPORT = "import"
+    METHOD_CALL = "method_call"

src/domain/value_objects/qualified_name.py

@@ -0,0 +1,78 @@
+"""QualifiedName value object - represents a fully qualified name."""
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class QualifiedName:
+    """
+    QualifiedName value object representing a fully qualified name.
+
+    A qualified name follows the format: package.Class or package.Class.method
+    Examples:
+        - com.example.orders.OrderService
+        - com.example.orders.OrderService.createOrder
+
+    Attributes:
+        value: The fully qualified name string
+
+    Business Rules:
+        - Must contain at least one dot (package separator)
+        - Cannot be None or empty
+        - Immutable (frozen dataclass)
+    """
+    value: str
+
+    def __post_init__(self):
+        """Validate business rules after initialization."""
+        if self.value is None:
+            raise ValueError("Qualified name cannot be None or empty")
+
+        if not self.value or "." not in self.value:
+            raise ValueError("Qualified name must contain package")
+
+    def __str__(self) -> str:
+        """Return string representation."""
+        return self.value
+
+    def get_package(self) -> str:
+        """
+        Extract package from qualified name.
+
+        Returns:
+            Package name (everything before the last class/method part)
+
+        Example:
+            com.example.orders.OrderService -> com.example.orders
+            com.example.orders.OrderService.createOrder -> com.example.orders
+        """
+        parts = self.value.split(".")
+
+        # If it's package.Class.method, package is everything except last 2 parts
+        # If it's package.Class, package is everything except last part
+        # Heuristic: if last part starts with lowercase, it's a method
+        if len(parts) >= 3 and parts[-1][0].islower():
+            # package.Class.method -> package
+            return ".".join(parts[:-2])
+        else:
+            # package.Class -> package
+            return ".".join(parts[:-1])
+
+    def get_class_name(self) -> str:
+        """
+        Extract class name from qualified name.
+
+        Returns:
+            Class name (simple name without package)
+
+        Example:
+            com.example.orders.OrderService -> OrderService
+            com.example.orders.OrderService.createOrder -> OrderService
+        """
+        parts = self.value.split(".")
+
+        # If last part starts with lowercase, it's a method, so class is second-to-last
+        if len(parts) >= 2 and parts[-1][0].islower():
+            return parts[-2]
+        else:
+            # Last part is the class
+            return parts[-1]

src/infrastructure/exceptions.py

@@ -0,0 +1,41 @@
+"""
+Infrastructure Layer Exceptions (Task 9.3)
+
+Exception hierarchy for infrastructure layer errors.
+"""
+
+
+class InfrastructureException(Exception):
+    """Base exception for infrastructure layer errors."""
+
+    def __init__(self, message: str, details: dict | None = None):
+        """
+        Initialize infrastructure exception.
+
+        Args:
+            message: Human-readable error message
+            details: Optional dict with additional context
+        """
+        super().__init__(message)
+        self.message = message
+        self.details = details or {}
+
+
+class OpenAIAPIError(InfrastructureException):
+    """Error communicating with OpenAI API."""
+    pass
+
+
+class QdrantConnectionError(InfrastructureException):
+    """Error connecting to or communicating with Qdrant."""
+    pass
+
+
+class Neo4jConnectionError(InfrastructureException):
+    """Error connecting to or communicating with Neo4j."""
+    pass
+
+
+class ParseError(InfrastructureException):
+    """Error parsing source code."""
+    pass

src/infrastructure/external_apis/ollama_embedding_provider.py

@@ -0,0 +1,134 @@
+"""
+Ollama Embedding Provider — generates embeddings using a local Ollama instance.
+
+No API keys, no rate limits, fully local.
+
+Supported models (install with `ollama pull <model>`):
+  nomic-embed-text   — 768-dim,  fast, good quality  (recommended)
+  mxbai-embed-large  — 1024-dim, best quality, slower
+  all-minilm         — 384-dim,  very fast, lower quality
+
+Set in .env:
+  EMBEDDING_PROVIDER=ollama
+  OLLAMA_BASE_URL=http://localhost:11434
+  OLLAMA_EMBEDDING_MODEL=nomic-embed-text
+  OLLAMA_EMBEDDING_DIM=768
+  QDRANT_VECTOR_SIZE=768   ← must match the model dimension
+
+Install Ollama: https://ollama.com/download
+Pull a model:  ollama pull nomic-embed-text
+"""
+from __future__ import annotations
+
+import structlog
+import httpx
+
+logger = structlog.get_logger(__name__)
+
+
+class OllamaEmbeddingProvider:
+    """
+    Local embedding provider using Ollama.
+
+    Supports batch processing (sequentially — Ollama processes one at a time).
+    No rate limits, no API key required.
+    """
+
+    def __init__(self, config=None):
+        base_url = "http://localhost:11434"
+        model = "nomic-embed-text"
+
+        if config is not None:
+            base_url = getattr(config, "ollama_base_url", base_url)
+            model = getattr(config, "ollama_embedding_model", model)
+
+        self.base_url = base_url.rstrip("/")
+        self.model = model
+        self._client: httpx.AsyncClient | None = None
+
+    @property
+    def client(self) -> httpx.AsyncClient:
+        if self._client is None:
+            self._client = httpx.AsyncClient(
+                timeout=120.0,
+                limits=httpx.Limits(max_connections=4)
+            )
+        return self._client
+
+    async def embed_batch(
+        self,
+        texts: list[str],
+        batch_size: int = 10,
+    ) -> list[list[float]]:
+        """
+        Generate embeddings for a list of texts using Ollama.
+
+        Ollama's /api/embed endpoint supports multiple inputs in one call.
+        We process in batches to avoid memory issues with large lists.
+
+        Args:
+            texts: List of text strings to embed
+            batch_size: Number of texts per Ollama API call (default 10)
+
+        Returns:
+            List of embedding vectors
+        """
+        if not texts:
+            return []
+
+        all_embeddings: list[list[float]] = []
+
+        for i in range(0, len(texts), batch_size):
+            batch = texts[i:i + batch_size]
+            embeddings = await self._embed_batch_ollama(batch)
+            all_embeddings.extend(embeddings)
+
+        logger.info(
+            "embeddings_generated",
+            model=self.model,
+            total_texts=len(texts),
+            total_embeddings=len(all_embeddings),
+            provider="ollama",
+        )
+        return all_embeddings
+
+    async def _embed_batch_ollama(self, texts: list[str]) -> list[list[float]]:
+        """Call Ollama /api/embed for a batch of texts."""
+        url = f"{self.base_url}/api/embed"
+
+        payload = {
+            "model": self.model,
+            "input": texts,
+        }
+
+        try:
+            response = await self.client.post(url, json=payload)
+            response.raise_for_status()
+            data = response.json()
+
+            # Ollama /api/embed returns {"embeddings": [[...], [...]]}
+            embeddings = data.get("embeddings", [])
+
+            if len(embeddings) != len(texts):
+                raise ValueError(
+                    f"Ollama returned {len(embeddings)} embeddings for {len(texts)} texts"
+                )
+
+            return embeddings
+
+        except httpx.ConnectError:
+            raise ConnectionError(
+                f"Cannot connect to Ollama at {self.base_url}. "
+                "Make sure Ollama is running: `ollama serve`"
+            )
+        except httpx.HTTPStatusError as e:
+            if e.response.status_code == 404:
+                raise ValueError(
+                    f"Model '{self.model}' not found in Ollama. "
+                    f"Pull it first: `ollama pull {self.model}`"
+                )
+            raise
+
+    async def close(self):
+        if self._client is not None:
+            await self._client.aclose()

src/infrastructure/external_apis/openai_embedding_provider.py

@@ -0,0 +1,231 @@
+"""
+OpenAI Embedding Provider Implementation (Task 6.1)
+
+Generates embeddings via OpenAI API with support for Flow AI proxy.
+Implements retry logic with exponential backoff for resilience.
+"""
+from dataclasses import dataclass
+from typing import Any
+import structlog
+import httpx
+from tenacity import (
+    retry,
+    stop_after_attempt,
+    wait_exponential,
+    retry_if_exception_type
+)
+
+from src.config.settings import EmbeddingConfig, get_settings
+
+logger = structlog.get_logger(__name__)
+
+
+class EmbeddingProviderError(Exception):
+    """Error raised when embedding generation fails"""
+    pass
+
+
+class OpenAIEmbeddingProvider:
+    """
+    OpenAI API client for generating embeddings.
+
+    Supports:
+    - OpenAI standard endpoint
+    - Flow AI (CI&T proxy) with custom headers
+    - Local embedding servers
+    - Batch processing (10 texts per API call)
+    - Automatic retry with exponential backoff (10 attempts, 2-30s)
+    - 1536-dimensional embeddings (text-embedding-3-small)
+
+    Configuration via .env:
+    - OPENAI_API_KEY: API key (required)
+    - OPENAI_BASE_URL: Base URL (default: https://api.openai.com/v1)
+    - OPENAI_EMBEDDING_MODEL: Model name (default: text-embedding-3-small)
+
+    Requirements: 8.1-8.7
+    """
+
+    def __init__(
+        self,
+        config: EmbeddingConfig | None = None,
+        client: httpx.AsyncClient | None = None
+    ):
+        """
+        Initialize embedding provider.
+
+        Args:
+            config: Embedding configuration (default: loaded from .env)
+            client: Optional httpx client (for testing)
+        """
+        if config is None:
+            config = get_settings().embedding
+
+        self.api_key = config.openai_api_key
+        self.base_url = config.openai_base_url.rstrip("/")
+        self.model = config.openai_embedding_model
+        self._client = client
+        self._is_flow_ai = "flow.ciandt.com" in self.base_url
+
+    @property
+    def client(self) -> httpx.AsyncClient:
+        """Get or create httpx client"""
+        if self._client is None:
+            # Desabilitar verificação SSL para ambientes corporativos
+            self._client = httpx.AsyncClient(
+                timeout=180.0,
+                verify=False,  # Desabilita verificação SSL
+                limits=httpx.Limits(max_connections=10)
+            )
+            logger.debug("httpx_client_created", verify_ssl=False)
+        return self._client
+
+    async def embed_batch(
+        self,
+        texts: list[str],
+        batch_size: int = 10
+    ) -> list[list[float]]:
+        """
+        Generate embeddings for batch of texts.
+
+        Processes texts in batches for optimal API usage.
+        Automatically retries on failures with exponential backoff.
+
+        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
+        """
+        all_embeddings = []
+
+        # Process in batches
+        for i in range(0, len(texts), batch_size):
+            batch_texts = texts[i:i + batch_size]
+
+            try:
+                # Call API for this batch with retry
+                batch_embeddings = await self._generate_embeddings_with_retry(batch_texts)
+                all_embeddings.extend(batch_embeddings)
+
+            except Exception as e:
+                logger.error(
+                    "embedding_generation_failed",
+                    error=str(e),
+                    error_type=type(e).__name__
+                )
+                raise EmbeddingProviderError(f"Failed to generate embeddings: {e}")
+
+        logger.info(
+            "embeddings_generated",
+            total_texts=len(texts),
+            total_embeddings=len(all_embeddings),
+            model=self.model
+        )
+
+        return all_embeddings
+
+    @retry(
+        stop=stop_after_attempt(10),
+        wait=wait_exponential(min=2, max=30),
+        retry=retry_if_exception_type(httpx.HTTPError)
+    )
+    async def _generate_embeddings_with_retry(self, texts: list[str]) -> list[list[float]]:
+        """
+        Generate embeddings with retry logic.
+
+        Args:
+            texts: List of texts to embed
+
+        Returns:
+            List of embedding vectors
+
+        Raises:
+            httpx.HTTPError: On API failures (for retry)
+        """
+        return await self._generate_embeddings(texts)
+
+    async def _generate_embeddings(self, texts: list[str]) -> list[list[float]]:
+        """
+        Generate embeddings for a single batch via API call.
+
+        Args:
+            texts: List of texts (max 10)
+
+        Returns:
+            List of embedding vectors
+
+        Raises:
+            httpx.HTTPError: On API failures
+            EmbeddingProviderError: On validation failures
+        """
+        # Build headers
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+
+        # Add Flow AI custom header if needed
+        if self._is_flow_ai:
+            headers["flowAgent"] = "knowledge-graph-indexing"
+
+        # Build payload
+        payload = {
+            "model": self.model,
+            "input": texts,
+            "encoding_format": "float"
+        }
+
+        # POST to API - endpoint depends on API type
+        if self._is_flow_ai:
+            # Flow AI requires /v1/openai/embeddings path
+            url = f"{self.base_url}/v1/openai/embeddings"
+        else:
+            # OpenAI standard endpoint
+            url = f"{self.base_url}/embeddings"
+
+        logger.info(
+            "embedding_request_starting",
+            url=url,
+            is_flow_ai=self._is_flow_ai,
+            texts_count=len(texts),
+            model=self.model
+        )
+
+        response = await self.client.post(
+            url=url,
+            headers=headers,
+            json=payload
+        )
+
+        # Validate response
+        response.raise_for_status()  # Let httpx.HTTPError propagate for retry
+
+        # Parse response
+        data = response.json()
+
+        # Extract embeddings
+        if "data" not in data:
+            raise EmbeddingProviderError("API response missing 'data' field")
+
+        embeddings_data = data["data"]
+
+        # Validate count
+        if len(embeddings_data) != len(texts):
+            raise EmbeddingProviderError(
+                f"Embedding count mismatch: expected {len(texts)}, "
+                f"got {len(embeddings_data)}"
+            )
+
+        # Extract embedding vectors
+        embeddings = [item["embedding"] for item in embeddings_data]
+
+        return embeddings
+
+    async def close(self):
+        """Close the HTTP client"""
+        if self._client is not None:
+            await self._client.aclose()

src/infrastructure/parsing/__init__.py

@@ -0,0 +1,20 @@
+"""Infrastructure parsing module."""
+from src.infrastructure.parsing.tree_sitter_java_parser import TreeSitterJavaParser, ParseError
+from src.infrastructure.parsing.tree_sitter_typescript_parser import TreeSitterTypeScriptParser
+from src.infrastructure.parsing.maven_dependency_parser import MavenDependencyParser
+from src.infrastructure.parsing.gradle_dependency_parser import GradleDependencyParser
+from src.infrastructure.parsing.config_file_parser import ConfigFileParser, ParsedConfig
+from src.infrastructure.parsing.npm_package_dependency_parser import NpmPackageDependencyParser
+from src.infrastructure.parsing.microfrontend_config_parser import MicrofrontendConfigParser
+
+__all__ = [
+    "TreeSitterJavaParser",
+    "TreeSitterTypeScriptParser",
+    "ParseError",
+    "MavenDependencyParser",
+    "GradleDependencyParser",
+    "ConfigFileParser",
+    "ParsedConfig",
+    "NpmPackageDependencyParser",
+    "MicrofrontendConfigParser",
+]