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

src/config/container.py

@@ -0,0 +1,211 @@
+"""
+Container de injeção de dependências usando dependency-injector.
+
+Requirements: 12.1, 12.2, 12.3, 12.4, 12.5
+"""
+from functools import lru_cache
+
+from dependency_injector import containers, providers
+
+from src.config.settings import Settings
+
+
+def _build_embedding_provider(config):
+    """
+    Factory that returns the correct embedding provider based on EMBEDDING_PROVIDER env var.
+
+    - "flow" or "openai" → OpenAIEmbeddingProvider (uses OPENAI_BASE_URL + OPENAI_API_KEY)
+    - "ollama"           → OllamaEmbeddingProvider (uses OLLAMA_BASE_URL + OLLAMA_EMBEDDING_MODEL)
+    """
+    provider_type = getattr(config, "embedding_provider", "flow").lower()
+
+    if provider_type == "ollama":
+        from src.infrastructure.external_apis.ollama_embedding_provider import OllamaEmbeddingProvider
+        import structlog
+        structlog.get_logger(__name__).info(
+            "embedding_provider_selected",
+            provider="ollama",
+            model=getattr(config, "ollama_embedding_model", "nomic-embed-text"),
+            base_url=getattr(config, "ollama_base_url", "http://localhost:11434"),
+        )
+        return OllamaEmbeddingProvider(config=config)
+    else:
+        from src.infrastructure.external_apis.openai_embedding_provider import OpenAIEmbeddingProvider
+        import structlog
+        structlog.get_logger(__name__).info(
+            "embedding_provider_selected",
+            provider=provider_type,
+            model=getattr(config, "openai_embedding_model", "text-embedding-3-small"),
+            base_url=getattr(config, "openai_base_url", ""),
+        )
+        return OpenAIEmbeddingProvider(config=config)
+
+
+class Container(containers.DeclarativeContainer):
+    """
+    Container central de injeção de dependências.
+
+    Registra todos os componentes da aplicação e gerencia seu ciclo de vida:
+    - Configurações (singleton)
+    - Componentes de infraestrutura (singletons)
+    - Use cases (factories)
+    """
+
+    # Configuração
+    config = providers.Singleton(Settings)
+
+    # === Application Services ===
+    file_scanner = providers.Factory(
+        "src.application.services.file_scanner_service.FileScannerService"
+    )
+
+    # === Infrastructure - Parsing ===
+    java_parser = providers.Singleton(  # FIXED: Renamed from tree_sitter_parser (Task 7.1)
+        "src.infrastructure.parsing.tree_sitter_java_parser.TreeSitterJavaParser"
+    )
+
+    typescript_parser = providers.Singleton(  # Task 12.1
+        "src.infrastructure.parsing.tree_sitter_typescript_parser.TreeSitterTypeScriptParser"
+    )
+
+    npm_parser = providers.Singleton(  # Task 12.2
+        "src.infrastructure.parsing.npm_package_dependency_parser.NpmPackageDependencyParser"
+    )
+
+    microfrontend_parser = providers.Factory(  # Task 12.3
+        "src.infrastructure.parsing.microfrontend_config_parser.MicrofrontendConfigParser",
+        typescript_parser=typescript_parser  # Inject typescript_parser dependency
+    )
+
+    config_parser = providers.Singleton(  # Task 12.4 (for DependencyExtractor)
+        "src.infrastructure.parsing.config_file_parser.ConfigFileParser"
+    )
+
+    # === Domain Services ===
+    dependency_extractor = providers.Factory(  # Task 12.4
+        "src.domain.services.dependency_extractor.DependencyExtractor",
+        typescript_parser=typescript_parser,
+        npm_parser=npm_parser,
+        microfrontend_parser=microfrontend_parser,
+        config_parser=config_parser
+    )
+
+    chunk_builder = providers.Factory(
+        "src.domain.services.semantic_chunk_builder.SemanticChunkBuilder"
+    )
+
+    # === Infrastructure - External APIs ===
+    # Embedding provider is selected by EMBEDDING_PROVIDER env var:
+    #   "flow"   → OpenAIEmbeddingProvider with CI&T Flow proxy (default)
+    #   "openai" → OpenAIEmbeddingProvider with OpenAI directly
+    #   "ollama" → OllamaEmbeddingProvider with local Ollama instance
+    embedding_provider = providers.Singleton(
+        _build_embedding_provider,
+        config=config.provided.embedding,
+    )
+
+    # === Infrastructure - Clients ===
+    qdrant_client = providers.Singleton(
+        "qdrant_client.QdrantClient",
+        url=config.provided.qdrant_url
+    )
+
+    # Neo4j driver - usar Callable para chamar método estático
+    neo4j_driver = providers.Resource(
+        lambda uri, user, password: __import__('neo4j').AsyncGraphDatabase.driver(
+            uri, auth=(user, password)
+        ),
+        uri=config.provided.neo4j_uri,
+        user=config.provided.neo4j_user,
+        password=config.provided.neo4j_password
+    )
+
+    # === Infrastructure - Persistence ===
+    qdrant_repository = providers.Singleton(
+        "src.infrastructure.persistence.qdrant_vector_repository.QdrantVectorRepository",
+        client=qdrant_client,
+        collection_name=config.provided.qdrant_collection,
+        batch_size=providers.Object(1000),
+        vector_size=config.provided.qdrant_vector_size,
+    )
+
+    neo4j_repository = providers.Singleton(
+        "src.infrastructure.persistence.neo4j_dependency_repository.Neo4jDependencyGraphRepository",
+        driver=neo4j_driver,
+        batch_size=providers.Object(100)
+    )
+
+    sql_parser = providers.Singleton(
+        "src.infrastructure.parsing.sql_schema_parser.SqlSchemaParser"
+    )
+
+    python_parser = providers.Singleton(
+        "src.infrastructure.parsing.python_parser.PythonParser"
+    )
+
+    groovy_parser = providers.Singleton(
+        "src.infrastructure.parsing.groovy_parser.GroovyParser"
+    )
+
+    # === Use Cases ===
+    index_repository_use_case = providers.Factory(
+        "src.application.use_cases.index_repository_use_case.IndexRepositoryUseCase",
+        file_scanner=file_scanner,
+        java_parser=java_parser,
+        typescript_parser=typescript_parser,
+        dependency_extractor=dependency_extractor,
+        chunk_builder=chunk_builder,
+        embedding_provider=embedding_provider,
+        qdrant_repository=qdrant_repository,
+        neo4j_repository=neo4j_repository,
+        sql_parser=sql_parser,
+        python_parser=python_parser,
+        groovy_parser=groovy_parser,
+    )
+
+    indexing_orchestrator = providers.Factory(
+        "src.application.use_cases.indexing_orchestrator.IndexingOrchestrator",
+        index_repository_use_case=index_repository_use_case
+    )
+
+    index_batch_use_case = providers.Factory(
+        "src.application.use_cases.index_batch_use_case.IndexBatchUseCase",
+        orchestrator=indexing_orchestrator,
+        settings=config
+    )
+
+    list_repositories_use_case = providers.Factory(
+        "src.application.use_cases.list_repositories_use_case.ListRepositoriesUseCase",
+        graph_repository=neo4j_repository
+    )
+
+    clear_all_data_use_case = providers.Factory(
+        "src.application.use_cases.clear_all_data_use_case.ClearAllDataUseCase",
+        graph_repository=neo4j_repository,
+        qdrant_client=qdrant_client,
+        collection_name="code_chunks"
+    )
+
+    graph_export_repository = providers.Singleton(
+        "src.infrastructure.persistence.graph_export_repository.GraphExportRepository",
+        driver=neo4j_driver,
+    )
+
+    relationship_repository = providers.Singleton(
+        "src.infrastructure.persistence.repository_relationship_repository.RepositoryRelationshipRepository",
+        driver=neo4j_driver,
+    )
+
+
+@lru_cache
+def get_container() -> Container:
+    """
+    Retorna instância singleton do Container.
+
+    Usa @lru_cache para garantir que apenas uma instância do container
+    é criada e reutilizada em toda a aplicação.
+
+    Returns:
+        Container: Container de injeção de dependências
+    """
+    return Container()

src/config/logging_config.py

@@ -0,0 +1,123 @@
+"""
+Configuração de logging estruturado com structlog.
+
+Requirements: 11.1, 11.2, 11.3, 11.4, 11.5
+"""
+import logging
+import sys
+from typing import Any, Literal
+
+import structlog
+from structlog.types import EventDict, WrappedLogger
+
+
+# Lista de campos sensíveis que devem ser sanitizados
+SENSITIVE_FIELDS = {
+    "password",
+    "api_key",
+    "token",
+    "secret",
+    "authorization",
+    "auth",
+    "apikey",
+    "access_token",
+    "refresh_token",
+}
+
+
+def sanitize_event(
+    logger: WrappedLogger,
+    method_name: str,
+    event_dict: EventDict
+) -> EventDict:
+    """
+    Sanitiza dados sensíveis substituindo valores por ***REDACTED***.
+
+    Args:
+        logger: Logger do structlog
+        method_name: Nome do método sendo chamado
+        event_dict: Dicionário do evento de log
+
+    Returns:
+        EventDict com dados sensíveis sanitizados
+    """
+    for key in list(event_dict.keys()):
+        # Verificar se a chave é sensível (case-insensitive)
+        if key.lower() in SENSITIVE_FIELDS:
+            event_dict[key] = "***REDACTED***"
+
+    return event_dict
+
+
+def configure_logging(
+    log_level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] = "INFO"
+) -> None:
+    """
+    Configura o sistema de logging estruturado com structlog.
+
+    Configuração inclui:
+    - Formato JSON
+    - Timestamp ISO8601
+    - Nível de log
+    - Nome do logger
+    - Mensagem e contexto estruturado
+    - Sanitização de dados sensíveis
+
+    Args:
+        log_level: Nível de log (padrão: INFO)
+    """
+    # Mapear string para nível do logging
+    level_map = {
+        "DEBUG": logging.DEBUG,
+        "INFO": logging.INFO,
+        "WARNING": logging.WARNING,
+        "ERROR": logging.ERROR,
+        "CRITICAL": logging.CRITICAL,
+    }
+    numeric_level = level_map.get(log_level.upper(), logging.INFO)
+
+    # Configurar logging padrão do Python
+    logging.basicConfig(
+        format="%(message)s",
+        stream=sys.stdout,
+        level=numeric_level,
+    )
+
+    # Configurar structlog
+    structlog.configure(
+        processors=[
+            # Adicionar nível de log
+            structlog.stdlib.add_log_level,
+            # Adicionar nome do logger
+            structlog.stdlib.add_logger_name,
+            # Adicionar timestamp ISO8601
+            structlog.processors.TimeStamper(fmt="iso"),
+            # Sanitizar dados sensíveis
+            sanitize_event,
+            # Adicionar informações de exceção
+            structlog.processors.ExceptionRenderer(),
+            # Processar stack info
+            structlog.processors.StackInfoRenderer(),
+            # Formatar para dict
+            structlog.processors.dict_tracebacks,
+            # Renderizar como JSON
+            structlog.processors.JSONRenderer(),
+        ],
+        wrapper_class=structlog.stdlib.BoundLogger,
+        context_class=dict,
+        logger_factory=structlog.stdlib.LoggerFactory(),
+        cache_logger_on_first_use=True,
+    )
+
+
+def get_logger(name: str) -> structlog.stdlib.BoundLogger:
+    """
+    Retorna um logger estruturado configurado.
+
+    Args:
+        name: Nome do logger (geralmente __name__ do módulo)
+
+    Returns:
+        Logger estruturado do structlog
+    """
+    return structlog.get_logger(name)

src/config/settings.py

@@ -0,0 +1,165 @@
+"""
+Sistema de configuração centralizado usando Pydantic Settings.
+
+Requirements: 10.1, 10.2, 10.3, 10.4, 10.5, 10.6
+"""
+from functools import lru_cache
+from pathlib import Path
+from typing import Literal
+
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+# Resolve .env relative to the project root (two levels up from this file)
+_PROJECT_ROOT = Path(__file__).parent.parent.parent
+_ENV_FILE = _PROJECT_ROOT / ".env"
+
+
+class DatabaseConfig:
+    """Agrupamento de configurações Neo4j (namespace apenas)."""
+    pass
+
+
+class VectorConfig:
+    """Agrupamento de configurações Qdrant (namespace apenas)."""
+    pass
+
+
+class EmbeddingConfig:
+    """Agrupamento de configurações OpenAI (namespace apenas)."""
+    pass
+
+
+class RepositoryConfig:
+    """Agrupamento de configurações de repositórios (namespace apenas)."""
+    pass
+
+
+class Settings(BaseSettings):
+    """
+    Configurações centralizadas da aplicação.
+
+    Todas as configurações são carregadas de variáveis de ambiente via .env file.
+    """
+
+    # Configurações gerais
+    environment: Literal["development", "staging", "production"] = Field(
+        default="development",
+        description="Ambiente de execução"
+    )
+    log_level: Literal["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"] = Field(
+        default="INFO",
+        description="Nível de log"
+    )
+    api_port: int = Field(default=8000, description="Porta da API")
+
+    # Neo4j Database Configuration
+    neo4j_uri: str = Field(..., description="URI de conexão Neo4j (ex: bolt://localhost:7687)")
+    neo4j_user: str = Field(..., description="Usuário Neo4j")
+    neo4j_password: str = Field(..., description="Senha Neo4j")
+    neo4j_pool_size: int = Field(default=50, description="Tamanho do pool de conexões")
+
+    # Qdrant Vector Database Configuration
+    qdrant_url: str = Field(..., description="URL do servidor Qdrant")
+    qdrant_collection: str = Field(default="code_chunks", description="Nome da collection")
+    qdrant_vector_size: int = Field(default=1536, description="Dimensão dos vetores")
+
+    # Embedding provider selection
+    # Options:
+    #   "openai"  — OpenAI API directly (default)
+    #   "flow"    — CI&T Flow proxy (uses OPENAI_BASE_URL + OPENAI_API_KEY)
+    #   "ollama"  — Local Ollama instance (free, no rate limits)
+    embedding_provider: Literal["openai", "flow", "ollama"] = Field(
+        default="flow",
+        description="Embedding provider: openai | flow | ollama"
+    )
+
+    # OpenAI / Flow Embeddings Configuration
+    openai_api_key: str = Field(default="", description="Chave API OpenAI ou Flow token")
+    openai_base_url: str = Field(
+        default="https://api.openai.com/v1",
+        description="URL base da API OpenAI ou Flow proxy"
+    )
+    openai_embedding_model: str = Field(
+        default="text-embedding-3-small",
+        description="Modelo de embedding OpenAI/Flow"
+    )
+
+    # Ollama Configuration (used when EMBEDDING_PROVIDER=ollama)
+    ollama_base_url: str = Field(
+        default="http://localhost:11434",
+        description="URL do servidor Ollama local"
+    )
+    ollama_embedding_model: str = Field(
+        default="nomic-embed-text",
+        description="Modelo de embedding Ollama (nomic-embed-text, mxbai-embed-large, all-minilm)"
+    )
+    # nomic-embed-text produces 768-dim vectors; mxbai-embed-large produces 1024-dim
+    # all-minilm produces 384-dim. Set QDRANT_VECTOR_SIZE to match.
+    ollama_embedding_dim: int = Field(
+        default=768,
+        description="Dimensão do vetor do modelo Ollama (768 para nomic-embed-text)"
+    )
+
+    # Repositories Configuration
+    repositories_path: str = Field(..., description="Caminho base para repositórios")
+
+    model_config = SettingsConfigDict(
+        env_file=str(_ENV_FILE),
+        env_file_encoding="utf-8",
+        case_sensitive=False,
+        extra="ignore",
+    )
+
+    @property
+    def database(self) -> DatabaseConfig:
+        """Acesso compatível ao namespace database."""
+        config = DatabaseConfig()
+        config.neo4j_uri = self.neo4j_uri
+        config.neo4j_user = self.neo4j_user
+        config.neo4j_password = self.neo4j_password
+        config.neo4j_pool_size = self.neo4j_pool_size
+        return config
+
+    @property
+    def vector(self) -> VectorConfig:
+        """Acesso compatível ao namespace vector."""
+        config = VectorConfig()
+        config.qdrant_url = self.qdrant_url
+        config.qdrant_collection = self.qdrant_collection
+        config.qdrant_vector_size = self.qdrant_vector_size
+        return config
+
+    @property
+    def embedding(self) -> EmbeddingConfig:
+        """Acesso compatível ao namespace embedding."""
+        config = EmbeddingConfig()
+        config.openai_api_key = self.openai_api_key
+        config.openai_base_url = self.openai_base_url
+        config.openai_embedding_model = self.openai_embedding_model
+        config.embedding_provider = self.embedding_provider
+        config.ollama_base_url = self.ollama_base_url
+        config.ollama_embedding_model = self.ollama_embedding_model
+        config.ollama_embedding_dim = self.ollama_embedding_dim
+        return config
+
+    @property
+    def repository(self) -> RepositoryConfig:
+        """Acesso compatível ao namespace repository."""
+        config = RepositoryConfig()
+        config.repositories_path = self.repositories_path
+        return config
+
+
+@lru_cache
+def get_settings() -> Settings:
+    """
+    Retorna instância singleton de Settings.
+
+    Usa @lru_cache para garantir que apenas uma instância é criada
+    e reutilizada em toda a aplicação.
+
+    Returns:
+        Settings: Configurações da aplicação
+    """
+    return Settings()

src/domain/entities/__init__.py

@@ -0,0 +1,20 @@
+"""Domain entities module."""
+from src.domain.entities.repository import Repository
+from src.domain.entities.code_file import CodeFile
+from src.domain.entities.ast_node import ASTNode
+from src.domain.entities.code_chunk import CodeChunk
+from src.domain.entities.dependency_graph import (
+    DependencyGraph,
+    DependencyNode,
+    DependencyEdge,
+)
+
+__all__ = [
+    "Repository",
+    "CodeFile",
+    "ASTNode",
+    "CodeChunk",
+    "DependencyGraph",
+    "DependencyNode",
+    "DependencyEdge",
+]

src/domain/entities/ast_node.py

@@ -0,0 +1,32 @@
+"""ASTNode entity - represents a parsed AST structure."""
+from dataclasses import dataclass, field
+
+
+@dataclass
+class ASTNode:
+    """
+    ASTNode entity representing a parsed Abstract Syntax Tree node.
+
+    Attributes:
+        node_type: Type of node (CLASS, METHOD, IMPORT, etc.)
+        name: Simple name of the element
+        qualified_name: Fully qualified name (e.g., com.example.Class.method)
+        line_start: Starting line number in source file
+        line_end: Ending line number in source file
+        metadata: Additional metadata (parameters, return_type, modifiers, etc.)
+
+    Business Rules:
+        - line_end must be >= line_start
+        - qualified_name must be unique within repository
+    """
+    node_type: str
+    name: str
+    qualified_name: str
+    line_start: int
+    line_end: int
+    metadata: dict = field(default_factory=dict)
+
+    def __post_init__(self):
+        """Validate business rules after initialization."""
+        if self.line_end < self.line_start:
+            raise ValueError("line_end must be >= line_start")

src/domain/entities/code_chunk.py

@@ -0,0 +1,45 @@
+"""CodeChunk entity - represents a semantic code chunk for embeddings."""
+from dataclasses import dataclass, field
+from uuid import UUID, uuid4
+
+
+@dataclass
+class CodeChunk:
+    """
+    CodeChunk entity representing a semantic code chunk.
+
+    Chunks are method-based (not line-based) and include rich metadata
+    for embedding generation and retrieval.
+
+    Attributes:
+        id: Unique identifier (UUID v4)
+        content: Full source code of the chunk
+        chunk_type: Type of chunk (METHOD, CLASS, IMPORT_BLOCK, etc.)
+        metadata: Rich metadata (qualified_name, parameters, line_range, etc.)
+        embedding: Optional embedding vector (1536 dimensions)
+
+    Business Rules:
+        - Chunks never contain partial methods (always complete)
+        - Embedding must be exactly 1536 dimensions if set
+        - Each chunk has a unique ID
+    """
+    content: str
+    chunk_type: str
+    metadata: dict
+    id: UUID = field(default_factory=uuid4)
+    embedding: list[float] | None = None
+
+    def set_embedding(self, embedding: list[float]) -> None:
+        """
+        Set the embedding vector for this chunk.
+
+        Args:
+            embedding: 1536-dimensional embedding vector
+
+        Raises:
+            ValueError: If embedding is not 1536 dimensions
+        """
+        if len(embedding) != 1536:
+            raise ValueError("Embedding must have 1536 dimensions")
+
+        self.embedding = embedding

src/domain/entities/code_file.py

@@ -0,0 +1,44 @@
+"""CodeFile entity - represents a source code file."""
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class CodeFile:
+    """
+    CodeFile entity representing a single source code file.
+
+    Attributes:
+        file_path: Relative path to file within repository
+        language: Programming language (e.g., "java")
+        content: Full source code content
+        ast_nodes: List of parsed AST nodes
+        chunks: List of semantic code chunks
+
+    Business Rules:
+        - Each file belongs to exactly one repository
+        - File path must be relative to repository root
+    """
+    file_path: Path
+    language: str
+    content: str
+    ast_nodes: list = field(default_factory=list)
+    chunks: list = field(default_factory=list)
+
+    def add_ast_node(self, ast_node) -> None:
+        """
+        Add an AST node extracted from this file.
+
+        Args:
+            ast_node: ASTNode entity to add
+        """
+        self.ast_nodes.append(ast_node)
+
+    def add_chunk(self, chunk) -> None:
+        """
+        Add a semantic chunk created from this file.
+
+        Args:
+            chunk: CodeChunk entity to add
+        """
+        self.chunks.append(chunk)