@ngocsangairvds/vsaf 3.2.14 → 3.2.16

package/tools/vds-scripts/hexagonal_orchestrator/src/vds_hexagonal_orchestrator/models.py

@@ -1,159 +0,0 @@
-#!/usr/bin/env python3
-"""
-Core data models for hexagonal compliance skill.
-
-Implements the stable evidence model from design.md section 3.
-"""
-
-from dataclasses import asdict, dataclass, field
-from typing import Literal
-
-# Type aliases
-LayerName = Literal[
-    "domain",
-    "application",
-    "driving_adapter",
-    "driven_adapter",
-    "unknown",
-]
-
-DetectionMode = Literal["python_ast", "tree_sitter", "regex", "java_ast"]
-
-
-@dataclass
-class LayerAssignment:
-    """
-    Represents the architectural layer assignment for a file.
-
-    Tracks how the layer was determined and with what confidence.
-    """
-
-    file_path: str
-    layer: LayerName
-    source: Literal["config_override", "path_rule", "import_clue", "unknown"]
-    confidence: float
-    matched_pattern: str | None = None
-    import_clues: list[str] = field(default_factory=list)
-
-    def to_dict(self) -> dict:
-        """Convert to dictionary for JSON serialization."""
-        return asdict(self)
-
-
-@dataclass
-class Violation:
-    """
-    Represents an architecture violation detected in the codebase.
-
-    All fields from design.md section 3, normalized for all analyzers.
-    """
-
-    violation_id: str
-    file_path: str
-    line_number: int
-    symbol_name: str | None
-    layer: LayerName
-    severity: Literal["critical", "major", "minor"]
-    category: str
-    detection_mode: DetectionMode
-    confidence: float
-    confidence_factors: dict[str, float]
-    code_snippet: str
-    context_before: str
-    context_after: str
-    remediation_steps: list[str]
-    evidence_status: Literal["confirmed_gap", "evidence_gap"]
-
-    def to_dict(self) -> dict:
-        """Convert to dictionary for JSON serialization."""
-        return asdict(self)
-
-
-@dataclass
-class ComplianceReport:
-    """
-    Complete compliance assessment report.
-
-    Aggregates all findings and metadata for a repository analysis.
-    """
-
-    repository_path: str
-    files_scanned: int
-    files_analyzed: int
-    coverage_ratio: float
-    compliance_level: float
-    confidence_score: float
-    layer_distribution: dict[str, int]
-    violations: list[Violation]
-
-    # Additional metadata
-    timestamp: str | None = None
-    total_violations: int = 0
-    violations_by_severity: dict[str, int] = field(default_factory=dict)
-    violations_by_layer: dict[str, dict[str, int]] = field(default_factory=dict)
-
-    # Performance metrics
-    analysis_duration_seconds: float = 0.0
-    files_per_second: float = 0.0
-
-    # Cache statistics (P3-305)
-    cache_hits: int = 0
-    cache_misses: int = 0
-    cache_enabled: bool = True
-
-    def calculate_metrics(self) -> None:
-        """Calculate derived performance metrics."""
-        if self.analysis_duration_seconds > 0 and self.files_analyzed > 0:
-            self.files_per_second = self.files_analyzed / self.analysis_duration_seconds
-
-    def to_dict(self) -> dict:
-        """Convert to dictionary for JSON serialization."""
-        return asdict(self)
-
-
-@dataclass
-class RepositoryProfile:
-    """
-    Profile of a repository's structure and language composition.
-
-    Built by RepositoryProfiler before layer classification.
-    """
-
-    repository_path: str
-    total_files: int
-    files_by_language: dict[str, int]
-    files_by_directory: dict[str, int]
-    excluded_directories: list[str]
-    language_distribution: dict[str, float]
-    source_files: list[str]
-    errors: list[str] = field(default_factory=list)
-
-    def to_dict(self) -> dict:
-        """Convert to dictionary for JSON serialization."""
-        return asdict(self)
-
-
-@dataclass
-class AnalyzerResult:
-    """
-    Raw result from a language analyzer before normalization.
-
-    Allows analyzers to return structured findings that are then
-    normalized into Violation objects.
-    """
-
-    file_path: str
-    line_number: int
-    symbol_name: str | None
-    category: str
-    severity: str
-    detection_mode: DetectionMode
-    confidence: float
-    code_snippet: str
-    context_before: str
-    context_after: str
-    details: dict = field(default_factory=dict)
-
-    def to_dict(self) -> dict:
-        """Convert to dictionary for JSON serialization."""
-        return asdict(self)

package/tools/vds-scripts/hexagonal_orchestrator/src/vds_hexagonal_orchestrator/profiler.py

@@ -1,451 +0,0 @@
-#!/usr/bin/env python3
-"""
-Repository Profiler for Hexagonal Compliance Analysis
-
-Analyzes repository structure to build a profile of source files,
-languages, and directory organization.
-"""
-
-import logging
-import os
-from collections import defaultdict
-from dataclasses import dataclass, field
-from pathlib import Path
-
-try:
-    from vds_hexagonal_orchestrator.models import RepositoryProfile
-except ImportError:
-    # Fallback definition if models.py is not yet available
-    @dataclass
-    class RepositoryProfile:
-        """Repository profile data model"""
-
-        repository_path: str = ""
-        total_files: int = 0
-        files_by_language: dict[str, int] = field(default_factory=dict)
-        files_by_directory: dict[str, int] = field(default_factory=dict)
-        excluded_directories: list[str] = field(default_factory=list)
-        language_distribution: dict[str, float] = field(default_factory=dict)
-        source_files: list[str] = field(default_factory=list)
-        errors: list[str] = field(default_factory=list)
-
-
-# Configure logging
-logger = logging.getLogger(__name__)
-
-
-class RepositoryProfiler:
-    """
-    Profiles a repository to identify source files, languages, and structure.
-
-    Attributes:
-        repo_path: Path to the repository root
-        exclusion_patterns: Set of directory names to exclude
-        language_extensions: Mapping of file extensions to languages
-    """
-
-    # Default directories to exclude (heavy directories)
-    DEFAULT_EXCLUSIONS = {
-        ".git",
-        ".svn",
-        ".hg",
-        "node_modules",
-        "venv",
-        ".venv",
-        "env",
-        ".env",
-        "__pycache__",
-        ".mypy_cache",
-        ".pytest_cache",
-        "build",
-        "dist",
-        "target",
-        "out",
-        "bin",
-        ".gradle",
-        ".mvn",
-        ".idea",
-        ".vscode",
-        ".settings",
-        "vendor",
-        "bower_components",
-        "jspm_packages",
-        ".tox",
-        ".nox",
-        "coverage",
-        ".coverage",
-        "htmlcov",
-        ".cache",
-        "eggs",
-        ".eggs",
-        "lib64",
-        "lib",
-        "include",
-        "share",
-        "doc",
-        "docs",
-        "documentation",
-    }
-
-    # Language detection by file extension
-    LANGUAGE_EXTENSIONS = {
-        # Python
-        ".py": "Python",
-        ".pyw": "Python",
-        ".pyi": "Python",
-        ".pyx": "Python",
-        # Java
-        ".java": "Java",
-        ".jar": "Java",
-        ".war": "Java",
-        # JavaScript/TypeScript
-        ".js": "JavaScript",
-        ".jsx": "JavaScript",
-        ".mjs": "JavaScript",
-        ".cjs": "JavaScript",
-        ".ts": "TypeScript",
-        ".tsx": "TypeScript",
-        # Other common languages
-        ".go": "Go",
-        ".rs": "Rust",
-        ".rb": "Ruby",
-        ".php": "PHP",
-        ".c": "C",
-        ".cpp": "C++",
-        ".cc": "C++",
-        ".cxx": "C++",
-        ".h": "C/C++",
-        ".hpp": "C++",
-        ".cs": "C#",
-        ".swift": "Swift",
-        ".kt": "Kotlin",
-        ".kts": "Kotlin",
-        ".scala": "Scala",
-        ".sc": "Scala",
-        ".clj": "Clojure",
-        ".ex": "Elixir",
-        ".exs": "Elixir",
-        ".erl": "Erlang",
-        ".hs": "Haskell",
-        ".lua": "Lua",
-        ".r": "R",
-        ".R": "R",
-        ".sql": "SQL",
-        ".sh": "Shell",
-        ".bash": "Shell",
-        ".zsh": "Shell",
-        ".ps1": "PowerShell",
-    }
-
-    # Target languages for hexagonal compliance (focus languages)
-    TARGET_LANGUAGES = {"Python", "Java", "TypeScript", "JavaScript"}
-
-    def __init__(
-        self,
-        repo_path: str,
-        exclusion_patterns: set[str] | None = None,
-        include_hidden: bool = False,
-        max_file_size: int = 10 * 1024 * 1024,  # 10 MB default
-    ):
-        """
-        Initialize the repository profiler.
-
-        Args:
-            repo_path: Path to the repository root
-            exclusion_patterns: Additional directory names to exclude
-            include_hidden: Whether to include hidden files/directories
-            max_file_size: Maximum file size in bytes to analyze
-        """
-        self.repo_path = Path(repo_path).resolve()
-        self.exclusion_patterns = (
-            self.DEFAULT_EXCLUSIONS.union(exclusion_patterns) if exclusion_patterns else self.DEFAULT_EXCLUSIONS.copy()
-        )
-        self.include_hidden = include_hidden
-        self.max_file_size = max_file_size
-
-        # Validate repository path
-        if not self.repo_path.exists():
-            raise ValueError(f"Repository path does not exist: {repo_path}")
-        if not self.repo_path.is_dir():
-            raise ValueError(f"Repository path is not a directory: {repo_path}")
-
-    def detect_language(self, file_path: Path) -> str | None:
-        """
-        Detect the programming language of a file based on its extension.
-
-        Args:
-            file_path: Path to the file
-
-        Returns:
-            Language name or None if not recognized
-        """
-        extension = file_path.suffix.lower()
-        return self.LANGUAGE_EXTENSIONS.get(extension)
-
-    def should_exclude(self, path: Path) -> bool:
-        """
-        Determine if a path should be excluded from analysis.
-
-        Args:
-            path: Path to check (can be absolute or relative)
-
-        Returns:
-            True if the path should be excluded
-        """
-        # Convert to relative path if it's absolute and within repo
-        try:
-            if path.is_absolute() and path.is_relative_to(self.repo_path):
-                rel_path = path.relative_to(self.repo_path)
-            else:
-                rel_path = path
-        except (ValueError, TypeError):
-            # If we can't make it relative, use as-is
-            rel_path = path
-
-        # Check if any component of the relative path is in exclusion patterns
-        for part in rel_path.parts:
-            if part in self.exclusion_patterns:
-                return True
-
-        # Exclude hidden files/directories unless explicitly included
-        # Only check parts of the relative path, not the absolute path
-        if not self.include_hidden:
-            for part in rel_path.parts:
-                if part.startswith(".") and part != ".":
-                    return True
-
-        return False
-
-    def analyze(self) -> RepositoryProfile:
-        """
-        Analyze the repository and build a profile.
-
-        Returns:
-            RepositoryProfile with analysis results
-        """
-        files_by_language: dict[str, int] = defaultdict(int)
-        files_by_directory: dict[str, int] = defaultdict(int)
-        excluded_dirs: set[str] = set()
-        source_files: list[str] = []
-        errors: list[str] = []
-
-        # Walk the repository
-        for root, dirs, files in os.walk(self.repo_path):
-            root_path = Path(root)
-
-            # Filter out excluded directories (modifies dirs in-place)
-            dirs[:] = [d for d in dirs if not self.should_exclude(root_path / d)]
-
-            # Track excluded directories
-            for d in dirs:
-                dir_path = root_path / d
-                if self.should_exclude(dir_path):
-                    excluded_dirs.add(str(dir_path.relative_to(self.repo_path)))
-
-            # Process files
-            for file_name in files:
-                file_path = root_path / file_name
-
-                # Skip excluded files
-                if self.should_exclude(file_path):
-                    continue
-
-                # Check file size
-                try:
-                    file_size = file_path.stat().st_size
-                    if file_size > self.max_file_size:
-                        logger.warning(f"Skipping large file: {file_path} ({file_size} bytes)")
-                        continue
-                except OSError as e:
-                    errors.append(f"Cannot read file size {file_path}: {e}")
-                    continue
-
-                # Detect language
-                language = self.detect_language(file_path)
-                if language:
-                    relative_path = str(file_path.relative_to(self.repo_path))
-
-                    # Count by language
-                    files_by_language[language] += 1
-
-                    # Count by directory
-                    relative_dir = str(file_path.parent.relative_to(self.repo_path))
-                    files_by_directory[relative_dir] += 1
-
-                    # Track source files
-                    source_files.append(relative_path)
-
-                # Try to read file content (for additional analysis)
-                try:
-                    # Just verify file is readable
-                    with open(file_path, encoding="utf-8", errors="ignore") as f:
-                        f.read(1)  # Read 1 byte to verify
-                except (OSError, UnicodeDecodeError) as e:
-                    errors.append(f"Cannot read file {file_path}: {e}")
-
-        # Calculate language distribution
-        total_files = sum(files_by_language.values())
-        language_distribution = {}
-        if total_files > 0:
-            for language, count in files_by_language.items():
-                language_distribution[language] = (count / total_files) * 100
-
-        # Create profile with collected data
-        profile = RepositoryProfile(
-            repository_path=str(self.repo_path),
-            total_files=total_files,
-            files_by_language=dict(files_by_language),
-            files_by_directory=dict(files_by_directory),
-            excluded_directories=list(excluded_dirs),
-            language_distribution=language_distribution,
-            source_files=source_files,
-            errors=errors,
-        )
-
-        logger.info(f"Profiled {total_files} source files across {len(files_by_language)} languages")
-
-        return profile
-
-    def get_summary(self, profile: RepositoryProfile) -> str:
-        """
-        Generate a human-readable summary of the repository profile.
-
-        Args:
-            profile: RepositoryProfile to summarize
-
-        Returns:
-            Summary string
-        """
-        lines = [
-            "Repository Profile Summary",
-            f"{'=' * 50}",
-            f"Repository: {self.repo_path}",
-            f"Total Source Files: {profile.total_files}",
-            "",
-            "Files by Language:",
-        ]
-
-        # Sort by count (descending)
-        sorted_languages = sorted(profile.files_by_language.items(), key=lambda x: x[1], reverse=True)
-
-        for language, count in sorted_languages:
-            pct = profile.language_distribution.get(language, 0)
-            lines.append(f"  {language}: {count} ({pct:.1f}%)")
-
-        if profile.excluded_directories:
-            lines.extend(
-                [
-                    "",
-                    f"Excluded {len(profile.excluded_directories)} directories",
-                ]
-            )
-
-        if profile.errors:
-            lines.extend(
-                [
-                    "",
-                    f"Encountered {len(profile.errors)} errors",
-                ]
-            )
-
-        return "\n".join(lines)
-
-    def filter_by_language(self, profile: RepositoryProfile, languages: set[str]) -> list[str]:
-        """
-        Filter source files by language.
-
-        Args:
-            profile: RepositoryProfile to filter
-            languages: Set of languages to include
-
-        Returns:
-            List of file paths for specified languages
-        """
-        filtered_files = []
-
-        for file_path in profile.source_files:
-            full_path = self.repo_path / file_path
-            language = self.detect_language(full_path)
-            if language in languages:
-                filtered_files.append(file_path)
-
-        return filtered_files
-
-    def get_target_language_files(self, profile: RepositoryProfile) -> list[str]:
-        """
-        Get files for target languages (Python, Java, TypeScript, JavaScript).
-
-        Args:
-            profile: RepositoryProfile to filter
-
-        Returns:
-            List of file paths for target languages
-        """
-        return self.filter_by_language(profile, self.TARGET_LANGUAGES)
-
-
-def profile_repository(
-    repo_path: str,
-    exclusion_patterns: set[str] | None = None,
-    include_hidden: bool = False,
-) -> RepositoryProfile:
-    """
-    Convenience function to profile a repository.
-
-    Args:
-        repo_path: Path to the repository root
-        exclusion_patterns: Additional directory names to exclude
-        include_hidden: Whether to include hidden files/directories
-
-    Returns:
-        RepositoryProfile with analysis results
-    """
-    profiler = RepositoryProfiler(
-        repo_path=repo_path,
-        exclusion_patterns=exclusion_patterns,
-        include_hidden=include_hidden,
-    )
-    return profiler.analyze()
-
-
-if __name__ == "__main__":
-    import json
-    import sys
-
-    # Configure logging for standalone execution
-    logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s")
-
-    if len(sys.argv) < 2:
-        print("Usage: python profiler.py <repo_path> [--include-hidden]")
-        sys.exit(1)
-
-    repo_path = sys.argv[1]
-    include_hidden = "--include-hidden" in sys.argv
-
-    try:
-        profiler = RepositoryProfiler(
-            repo_path=repo_path,
-            include_hidden=include_hidden,
-        )
-        profile = profiler.analyze()
-
-        # Print summary
-        print(profiler.get_summary(profile))
-        print()
-
-        # Print JSON profile
-        print("JSON Profile:")
-        profile_dict = {
-            "total_files": profile.total_files,
-            "files_by_language": profile.files_by_language,
-            "files_by_directory": profile.files_by_directory,
-            "excluded_directories": list(profile.excluded_directories),
-            "language_distribution": profile.language_distribution,
-            "source_files_count": len(profile.source_files),
-            "errors_count": len(profile.errors),
-        }
-        print(json.dumps(profile_dict, indent=2))
-
-    except Exception as e:
-        logger.exception(f"Failed to profile repository: {e}")
-        sys.exit(1)

package/tools/vds-scripts/hexagonal_orchestrator/test-config.yaml

@@ -1,38 +0,0 @@
-# Test configuration for hexagonal compliance analyzer
-version: "1.0"
-
-# Exclude certain directories
-exclude_patterns:
-  - "**/test/**"
-  - "**/tests/**"
-  - "**/__pycache__/**"
-  - "**/node_modules/**"
-
-# Custom layer mappings
-layer_indicators:
-  domain:
-    - "domain/"
-    - "entities/"
-    - "valueobjects/"
-  application:
-    - "application/"
-    - "services/"
-    - "usecases/"
-  driving_adapter:
-    - "api/"
-    - "controller/"
-    - "rest/"
-  driven_adapter:
-    - "infrastructure/"
-    - "persistence/"
-    - "adapter/"
-
-# Violation severity overrides
-severity_overrides:
-  # Treat certain violations as less severe for testing
-  "Forbidden import in domain layer": major
-
-# Confidence thresholds
-confidence_thresholds:
-  minimum_confidence: 0.7
-  high_confidence: 0.9

package/tools/vds-scripts/hexagonal_orchestrator/tests/__init__.py

@@ -1 +0,0 @@
-"""Tests for hexagonal_orchestrator package."""

package/tools/vds-scripts/hexagonal_orchestrator/tests/fixtures/__init__.py

@@ -1 +0,0 @@
-"""Test fixtures for hexagonal_orchestrator tests."""