@ngocsangairvds/vsaf 3.2.14 → 3.2.15

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

@@ -1,331 +0,0 @@
-#!/usr/bin/env python3
-"""
-Analysis caching for hexagonal compliance skill.
-
-Implements file-based caching with content hashing for efficient re-analysis.
-"""
-
-import hashlib
-import json
-import threading
-from datetime import datetime
-from pathlib import Path
-
-import structlog
-
-logger = structlog.get_logger()
-
-
-class CacheManager:
-    """
-    Manages analysis cache with file content hashing.
-
-    Cache Structure:
-        {
-          "version": "1.1",
-          "files": {
-            "<repo_id>:path/to/file.py": {
-              "hash": "sha256:abc123...",
-              "violations": [...],
-              "timestamp": "2026-03-20T10:00:00Z"
-            }
-          }
-        }
-
-    Cache Key Format:
-        <repo_id>:<relative_path>
-
-        Where repo_id is a SHA256 hash (first 12 characters) of the repository root path.
-        This ensures each repository has its own namespace, preventing cross-repository
-        cache pollution.
-
-    Cache Invalidation:
-        - File content hash changes
-        - Cache version mismatch
-        - --no-cache flag
-        - File deleted
-    """
-
-    CACHE_VERSION = "1.1"  # Incremented to invalidate old cache format
-    CACHE_FILE_NAME = "hexagonal_cache.json"
-    REPO_ID_LENGTH = 12  # First 12 chars of SHA256 hash for repo ID
-
-    def __init__(self, cache_dir: Path | None = None, enabled: bool = True):
-        """
-        Initialize cache manager.
-
-        Args:
-            cache_dir: Directory to store cache files (default: OS-specific cache dir)
-            enabled: Whether caching is enabled
-        """
-        self.enabled = enabled
-        self.cache_dir = self._get_cache_dir(cache_dir)
-        self.cache_file = self.cache_dir / self.CACHE_FILE_NAME
-        self.cache: dict = {}
-        self.lock = threading.Lock()
-
-        # Statistics
-        self.hits = 0
-        self.misses = 0
-
-        # Repository ID cache (avoid recomputing for same repo_root)
-        self._repo_id_cache: dict[str, str] = {}
-
-        if self.enabled:
-            self._load_cache()
-
-    def _get_cache_dir(self, cache_dir: Path | None) -> Path:
-        """Get cache directory, creating if necessary."""
-        if cache_dir:
-            cache_path = cache_dir
-        else:
-            # Use OS-specific cache directory
-            # macOS: ~/.cache/vds-hexagonal/
-            # Linux: ~/.cache/vds-hexagonal/
-            # Windows: ~\AppData\Local\vds-hexagonal\
-            home = Path.home()
-            cache_path = home / ".cache" / "vds-hexagonal"
-
-        # Create cache directory if it doesn't exist
-        cache_path.mkdir(parents=True, exist_ok=True)
-        logger.debug(f"Cache directory: {cache_path}")
-
-        return cache_path
-
-    def _load_cache(self) -> None:
-        """Load cache from disk if it exists and is valid."""
-        if not self.cache_file.exists():
-            logger.debug("No existing cache file found")
-            self.cache = self._create_empty_cache()
-            return
-
-        try:
-            with open(self.cache_file) as f:
-                loaded_cache = json.load(f)
-
-            # Validate cache version
-            if loaded_cache.get("version") != self.CACHE_VERSION:
-                logger.info("Cache version mismatch, creating new cache")
-                self.cache = self._create_empty_cache()
-                return
-
-            self.cache = loaded_cache
-            logger.debug(f"Loaded cache with {len(self.cache.get('files', {}))} entries")
-
-        except (OSError, json.JSONDecodeError) as e:
-            logger.warning(f"Failed to load cache, creating new one: {e}")
-            self.cache = self._create_empty_cache()
-
-    def _create_empty_cache(self) -> dict:
-        """Create an empty cache structure."""
-        return {"version": self.CACHE_VERSION, "files": {}}
-
-    def _save_cache(self) -> None:
-        """Save cache to disk."""
-        if not self.enabled:
-            return
-
-        try:
-            with self.lock, open(self.cache_file, "w") as f:
-                json.dump(self.cache, f, indent=2)
-            logger.debug(f"Saved cache to {self.cache_file}")
-        except OSError as e:
-            logger.exception(f"Failed to save cache: {e}")
-
-    def _compute_file_hash(self, file_path: Path) -> str:
-        """
-        Compute SHA256 hash of file content.
-
-        Args:
-            file_path: Path to the file
-
-        Returns:
-            Hash string in format "sha256:abc123..."
-        """
-        sha256_hash = hashlib.sha256()
-
-        try:
-            with open(file_path, "rb") as f:
-                # Read in chunks for memory efficiency
-                for chunk in iter(lambda: f.read(4096), b""):
-                    sha256_hash.update(chunk)
-            return f"sha256:{sha256_hash.hexdigest()}"
-        except OSError as e:
-            logger.exception(f"Failed to hash file {file_path}: {e}")
-            raise
-
-    def _compute_repo_id(self, repo_root: Path) -> str:
-        """
-        Compute a stable repository identifier from the repository root path.
-
-        This creates a unique namespace for each repository, preventing
-        cross-repository cache pollution when multiple repos have similar
-        file structures.
-
-        Args:
-            repo_root: Absolute path to repository root
-
-        Returns:
-            Repository identifier string (first 12 chars of SHA256 hash)
-        """
-        # Normalize the path to ensure consistency
-        repo_key = str(repo_root.resolve())
-
-        # Check cache to avoid recomputing
-        if repo_key in self._repo_id_cache:
-            return self._repo_id_cache[repo_key]
-
-        # Compute SHA256 hash of the repo path
-        sha256_hash = hashlib.sha256()
-        sha256_hash.update(repo_key.encode("utf-8"))
-        repo_id = sha256_hash.hexdigest()[: self.REPO_ID_LENGTH]
-
-        # Cache for future use
-        self._repo_id_cache[repo_key] = repo_id
-
-        logger.debug(f"Repo ID for {repo_root}: {repo_id}")
-        return repo_id
-
-    def _get_cache_key(self, file_path: Path, repo_root: Path) -> str:
-        """
-        Generate a repository-specific cache key for a file.
-
-        Cache key format: <repo_id>:<relative_path>
-
-        This ensures that:
-        1. Different repositories don't share cache entries
-        2. Same files in different repos are cached separately
-        3. Cache still works for same-repo re-runs
-
-        Args:
-            file_path: Absolute path to the file
-            repo_root: Repository root path
-
-        Returns:
-            Cache key string
-        """
-        repo_id = self._compute_repo_id(repo_root)
-
-        # Use relative path as part of the key
-        try:
-            relative_path = str(file_path.relative_to(repo_root))
-        except ValueError:
-            # File is not under repo_root, use absolute path
-            relative_path = str(file_path)
-
-        cache_key = f"{repo_id}:{relative_path}"
-        return cache_key
-
-    def get(self, file_path: Path, repo_root: Path) -> list[dict] | None:
-        """
-        Get cached violations for a file if still valid.
-
-        Args:
-            file_path: Absolute path to the file
-            repo_root: Repository root path
-
-        Returns:
-            List of violation dicts if cache hit, None if cache miss
-        """
-        if not self.enabled:
-            return None
-
-        # Generate repository-specific cache key
-        cache_key = self._get_cache_key(file_path, repo_root)
-
-        with self.lock:
-            # Check if file is in cache
-            if cache_key not in self.cache.get("files", {}):
-                self.misses += 1
-                logger.debug(f"Cache miss (not in cache): {cache_key}")
-                return None
-
-            cached_entry = self.cache["files"][cache_key]
-
-            # Verify file still exists
-            if not file_path.exists():
-                # File was deleted, remove from cache
-                del self.cache["files"][cache_key]
-                self._save_cache()
-                self.misses += 1
-                logger.debug(f"Cache miss (file deleted): {cache_key}")
-                return None
-
-            # Verify hash matches
-            try:
-                current_hash = self._compute_file_hash(file_path)
-            except OSError:
-                self.misses += 1
-                return None
-
-            if cached_entry.get("hash") != current_hash:
-                self.misses += 1
-                logger.debug(f"Cache miss (hash changed): {cache_key}")
-                return None
-
-            # Cache hit!
-            self.hits += 1
-            logger.debug(f"Cache hit: {cache_key}")
-            return cached_entry.get("violations", [])
-
-    def put(self, file_path: Path, repo_root: Path, violations: list[dict]) -> None:
-        """
-        Store violations for a file in cache.
-
-        Args:
-            file_path: Absolute path to the file
-            repo_root: Repository root path
-            violations: List of violation dicts to cache
-        """
-        if not self.enabled:
-            return
-
-        # Generate repository-specific cache key
-        cache_key = self._get_cache_key(file_path, repo_root)
-
-        try:
-            file_hash = self._compute_file_hash(file_path)
-        except OSError:
-            return
-
-        cache_entry = {"hash": file_hash, "violations": violations, "timestamp": datetime.now().isoformat()}
-
-        with self.lock:
-            self.cache["files"][cache_key] = cache_entry
-
-        # Save cache to disk
-        self._save_cache()
-        logger.debug(f"Cached violations for: {cache_key}")
-
-    def clear(self) -> None:
-        """Clear the cache."""
-        with self.lock:
-            self.cache = self._create_empty_cache()
-            self.hits = 0
-            self.misses = 0
-            self._repo_id_cache.clear()
-
-        self._save_cache()
-        logger.info("Cache cleared")
-
-    def get_stats(self) -> dict[str, int]:
-        """
-        Get cache statistics.
-
-        Returns:
-            Dict with 'hits', 'misses', 'entries' counts
-        """
-        with self.lock:
-            return {"hits": self.hits, "misses": self.misses, "entries": len(self.cache.get("files", {}))}
-
-    def get_hit_rate(self) -> float:
-        """
-        Calculate cache hit rate.
-
-        Returns:
-            Hit rate as a float between 0.0 and 1.0
-        """
-        total = self.hits + self.misses
-        if total == 0:
-            return 0.0
-        return self.hits / total

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

@@ -1,263 +0,0 @@
-#!/usr/bin/env python3
-"""
-Hybrid layer classifier for hexagonal architecture compliance.
-
-Implements three-source classification priority:
-1. config_override (highest priority)
-2. path_rule
-3. import_clue (lowest priority)
-
-Classification sources and confidence levels are tracked for evidence quality.
-"""
-
-import re
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import TYPE_CHECKING, Any, Optional
-
-# Import LayerAssignment from models
-try:
-# from vds_hexagonal_orchestrator.models import LayerAssignment as ModelsLayerAssignment
-
-    USE_MODELS_LAYER_ASSIGNMENT = True
-except ImportError:
-    USE_MODELS_LAYER_ASSIGNMENT = False
-
-if TYPE_CHECKING:
-    from vds_hexagonal_orchestrator.config import ConfigManager
-    from vds_hexagonal_orchestrator.models import RepositoryProfile
-
-
-@dataclass
-class LayerAssignment:
-    """
-    Represents a layer classification result with evidence tracking.
-
-    Attributes:
-        file_path: Path to the classified file
-        layer: Assigned layer (domain, application, driving_adapter, driven_adapter, unknown)
-        source: Classification source (config_override, path_rule, import_clue, unknown)
-        confidence: Classification confidence (0.0 to 1.0)
-        matched_pattern: Pattern that matched (if any)
-        import_clues: Import statements that influenced classification (if any)
-    """
-
-    file_path: str
-    layer: str
-    source: str
-    confidence: float
-    matched_pattern: str | None = None
-    import_clues: list[str] = field(default_factory=list)
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert to dictionary for JSON serialization."""
-        return {
-            "file_path": str(self.file_path),
-            "layer": self.layer,
-            "source": self.source,
-            "confidence": self.confidence,
-            "matched_pattern": self.matched_pattern,
-            "import_clues": self.import_clues,
-        }
-
-
-class LayerClassifier:
-    """
-    Hybrid layer classifier using three-source priority system.
-
-    Classification priority:
-    1. config_override (confidence: 1.0) - explicit user configuration
-    2. path_rule (confidence: 0.85) - path-based heuristics
-    3. import_clue (confidence: 0.65) - import-based heuristics
-
-    Files that cannot be classified are assigned to 'unknown' with low confidence.
-    """
-
-    # Default layer patterns (used when no config provided)
-    DEFAULT_LAYER_PATTERNS = {
-        "domain": [
-            r"/domain/",
-            r"/core/",
-            r"/model/",
-            r"/entities/",
-            r"/value.?object/",
-            r"/aggregate/",
-        ],
-        "application": [
-            r"/application/",
-            r"/use.?case/",
-            r"/service/",
-            r"/command/",
-            r"/query/",
-            r"/port/",
-            r"/dto/",
-        ],
-        "driving_adapter": [
-            r"/adapter.*web/",
-            r"/controller/",
-            r"/api/",
-            r"/rest/",
-            r"/graphql/",
-            r"/cli/",
-            r"/web/",
-            r"/presentation/",
-            r"/http/",
-            r"/grpc/",
-        ],
-        "driven_adapter": [
-            r"/adapter.*persistence/",
-            r"/repository/",
-            r"/infrastructure/",
-            r"/persistence/",
-            r"/dao/",
-            r"/external/",
-            r"/client/",
-            r"/integration/",
-        ],
-    }
-
-    def __init__(self, config_manager: Optional["ConfigManager"] = None):
-        """
-        Initialize the layer classifier.
-
-        Args:
-            config_manager: Optional configuration manager for custom patterns
-        """
-        self.config_manager = config_manager
-        self.layer_patterns = self._build_layer_patterns()
-
-    def _build_layer_patterns(self) -> dict[str, list[str]]:
-        """
-        Build layer patterns from config or use defaults.
-
-        Returns:
-            Dictionary mapping layer names to list of regex patterns
-        """
-        if not self.config_manager:
-            return self.DEFAULT_LAYER_PATTERNS
-
-        # Try to get layer patterns from config
-        try:
-            layers_config = self.config_manager.get("layers", {})
-            patterns = {}
-
-            for layer_name in ["domain", "application", "driving_adapter", "driven_adapter"]:
-                layer_patterns = layers_config.get(layer_name, {}).get("patterns", [])
-                if layer_patterns:
-                    # Convert glob patterns to regex
-                    regex_patterns = []
-                    for pattern in layer_patterns:
-                        # Simple conversion from glob to regex
-                        regex_pattern = pattern.replace("**", ".*").replace("*", "[^/]*")
-                        regex_patterns.append(regex_pattern)
-                    patterns[layer_name] = regex_patterns
-
-            return patterns if patterns else self.DEFAULT_LAYER_PATTERNS
-        except Exception:
-            return self.DEFAULT_LAYER_PATTERNS
-
-    def classify_file(self, file_path: Path, profile: Optional["RepositoryProfile"] = None) -> "LayerAssignment":
-        """
-        Classify a file into an architectural layer.
-
-        Args:
-            file_path: Path to the file to classify
-            profile: Optional repository profile for context
-
-        Returns:
-            LayerAssignment with classification details
-        """
-        file_path_str = str(file_path)
-
-        # Priority 1: Check config overrides
-        if self.config_manager:
-            override = self._check_config_override(file_path)
-            if override:
-                return LayerAssignment(
-                    file_path=file_path_str,
-                    layer=override,
-                    source="config_override",
-                    confidence=1.0,
-                    matched_pattern="config_override",
-                )
-
-        # Priority 2: Check path rules
-        layer, pattern = self._check_path_rules(file_path)
-        if layer:
-            return LayerAssignment(
-                file_path=file_path_str, layer=layer, source="path_rule", confidence=0.85, matched_pattern=pattern
-            )
-
-        # Priority 3: Check import clues (if profile available)
-        if profile:
-            layer, import_clues = self._check_import_clues(file_path, profile)
-            if layer:
-                return LayerAssignment(
-                    file_path=file_path_str,
-                    layer=layer,
-                    source="import_clue",
-                    confidence=0.65,
-                    matched_pattern=None,
-                    import_clues=import_clues,
-                )
-
-        # Default: unknown layer
-        return LayerAssignment(file_path=file_path_str, layer="unknown", source="unknown", confidence=0.0)
-
-    def _check_config_override(self, file_path: Path) -> str | None:
-        """
-        Check if file has a config override.
-
-        Args:
-            file_path: Path to check
-
-        Returns:
-            Layer name if override found, None otherwise
-        """
-        if not self.config_manager:
-            return None
-
-        return self.config_manager.get_layer_override(str(file_path))
-
-    def _check_path_rules(self, file_path: Path) -> tuple[str | None, str | None]:
-        """
-        Check path-based classification rules.
-
-        Args:
-            file_path: Path to check
-
-        Returns:
-            Tuple of (layer_name, matched_pattern) if found, (None, None) otherwise
-        """
-        file_path_str = str(file_path)
-
-        for layer, patterns in self.layer_patterns.items():
-            for pattern in patterns:
-                if re.search(pattern, file_path_str):
-                    return (layer, pattern)
-
-        return (None, None)
-
-    def _check_import_clues(self, file_path: Path, profile: "RepositoryProfile") -> tuple[str | None, list[str]]:
-        """
-        Check import-based classification clues.
-
-        Args:
-            file_path: Path to check
-            profile: Repository profile with import information
-
-        Returns:
-            Tuple of (layer_name, import_clues) if found, (None, []) otherwise
-        """
-        # This would analyze imports to determine layer
-        # For now, return None (import clue analysis not implemented)
-        return (None, [])
-
-    def get_layer_patterns(self) -> dict[str, list[str]]:
-        """
-        Get current layer patterns.
-
-        Returns:
-            Dictionary of layer patterns
-        """
-        return self.layer_patterns