delimit-cli 2.3.2 → 3.0.0

package/gateway/core/registry_v2.py

@@ -0,0 +1,132 @@
+"""
+Fixed Task Registry with proper versioning support
+V12 Core Hardening
+"""
+
+from typing import Callable, Dict, Optional, List, Tuple
+from functools import wraps
+import logging
+from packaging import version
+
+logger = logging.getLogger(__name__)
+
+
+class TaskRegistry:
+    """
+    Registry for task handlers with proper versioning
+    Key format: task_name:version (e.g., "validate-api:1.0")
+    """
+    
+    def __init__(self):
+        self._tasks: Dict[str, Callable] = {}
+        self._task_metadata: Dict[str, Dict] = {}
+        self._latest_versions: Dict[str, str] = {}  # task_name -> latest_version
+    
+    def register(self, task_name: str, version: str, **metadata):
+        """
+        Decorator to register a task handler with explicit version
+        
+        Args:
+            task_name: Name of the task (e.g., "validate-api")
+            version: Version string (e.g., "1.0", "2.0")
+            **metadata: Additional metadata (description, etc.)
+        """
+        def decorator(func: Callable):
+            # Create versioned key
+            task_key = f"{task_name}:{version}"
+            
+            @wraps(func)
+            def wrapper(*args, **kwargs):
+                return func(*args, **kwargs)
+            
+            # Store handler with versioned key
+            self._tasks[task_key] = wrapper
+            
+            # Store metadata
+            self._task_metadata[task_key] = {
+                "name": task_name,
+                "version": version,
+                "handler": func.__name__,
+                **metadata
+            }
+            
+            # Update latest version tracking
+            if task_name not in self._latest_versions:
+                self._latest_versions[task_name] = version
+            else:
+                # Compare versions properly
+                try:
+                    current = version.parse(self._latest_versions[task_name])
+                    new = version.parse(version)
+                    if new > current:
+                        self._latest_versions[task_name] = version
+                except:
+                    # Fallback to string comparison if not semantic versioning
+                    if version > self._latest_versions[task_name]:
+                        self._latest_versions[task_name] = version
+            
+            logger.info(f"Registered task: {task_key}")
+            return wrapper
+        return decorator
+    
+    def get_handler(self, task_name: str, version: Optional[str] = None) -> Optional[Callable]:
+        """
+        Get a task handler by name and optional version
+        
+        Args:
+            task_name: Task name (e.g., "validate-api")
+            version: Optional version (e.g., "1.0"). If None, returns latest.
+        
+        Returns:
+            Task handler callable or None if not found
+        """
+        if version:
+            # Explicit version requested
+            task_key = f"{task_name}:{version}"
+            return self._tasks.get(task_key)
+        else:
+            # No version specified, return latest
+            if task_name in self._latest_versions:
+                latest_version = self._latest_versions[task_name]
+                task_key = f"{task_name}:{latest_version}"
+                return self._tasks.get(task_key)
+            return None
+    
+    def list_tasks(self) -> List[str]:
+        """List all registered task keys (with versions)"""
+        return sorted(self._tasks.keys())
+    
+    def list_task_names(self) -> List[str]:
+        """List unique task names (without versions)"""
+        return sorted(set(self._latest_versions.keys()))
+    
+    def get_task_versions(self, task_name: str) -> List[str]:
+        """Get all registered versions for a task"""
+        versions = []
+        for key in self._tasks.keys():
+            if key.startswith(f"{task_name}:"):
+                version = key.split(":", 1)[1]
+                versions.append(version)
+        return sorted(versions)
+    
+    def has_task(self, task_name: str, version: Optional[str] = None) -> bool:
+        """Check if a task is registered"""
+        if version:
+            task_key = f"{task_name}:{version}"
+            return task_key in self._tasks
+        else:
+            return task_name in self._latest_versions
+    
+    def get_metadata(self, task_name: str, version: Optional[str] = None) -> Optional[Dict]:
+        """Get metadata for a task"""
+        if version:
+            task_key = f"{task_name}:{version}"
+        elif task_name in self._latest_versions:
+            task_key = f"{task_name}:{self._latest_versions[task_name]}"
+        else:
+            return None
+        return self._task_metadata.get(task_key)
+
+
+# Global registry instance
+task_registry = TaskRegistry()

package/gateway/core/registry_v3.py

@@ -0,0 +1,134 @@
+"""
+Fixed Task Registry with proper versioning support - No shadowing
+V12 Core Hardening Final
+"""
+
+from typing import Callable, Dict, Optional, List
+from functools import wraps
+import logging
+from packaging import version as pkg_version
+
+logger = logging.getLogger(__name__)
+
+
+class TaskRegistry:
+    """
+    Registry for task handlers with proper versioning
+    Key format: task_name:version (e.g., "validate-api:1.0")
+    Fixed version shadowing issue
+    """
+    
+    def __init__(self):
+        self._tasks: Dict[str, Callable] = {}
+        self._task_metadata: Dict[str, Dict] = {}
+        self._latest_versions: Dict[str, str] = {}  # task_name -> latest_version
+    
+    def register(self, task_name: str, task_version: str, **metadata):
+        """
+        Decorator to register a task handler with explicit version
+        
+        Args:
+            task_name: Name of the task (e.g., "validate-api")
+            task_version: Version string (e.g., "1.0", "2.0")
+            **metadata: Additional metadata (description, etc.)
+        """
+        def decorator(func: Callable):
+            # Create versioned key
+            task_key = f"{task_name}:{task_version}"
+            
+            @wraps(func)
+            def wrapper(*args, **kwargs):
+                return func(*args, **kwargs)
+            
+            # Store handler with versioned key
+            self._tasks[task_key] = wrapper
+            
+            # Store metadata
+            self._task_metadata[task_key] = {
+                "name": task_name,
+                "version": task_version,
+                "handler": func.__name__,
+                **metadata
+            }
+            
+            # Update latest version tracking
+            if task_name not in self._latest_versions:
+                self._latest_versions[task_name] = task_version
+            else:
+                # Compare versions properly using packaging.version
+                try:
+                    current = pkg_version.parse(self._latest_versions[task_name])
+                    new = pkg_version.parse(task_version)
+                    if new > current:
+                        self._latest_versions[task_name] = task_version
+                except Exception as e:
+                    # Fallback to string comparison if not semantic versioning
+                    logger.warning(f"Version comparison failed, using string comparison: {e}")
+                    if task_version > self._latest_versions[task_name]:
+                        self._latest_versions[task_name] = task_version
+            
+            logger.info(f"Registered task: {task_key}")
+            return wrapper
+        return decorator
+    
+    def get_handler(self, task_name: str, version: Optional[str] = None) -> Optional[Callable]:
+        """
+        Get a task handler by name and optional version
+        
+        Args:
+            task_name: Task name (e.g., "validate-api")
+            version: Optional version (e.g., "1.0"). If None, returns latest.
+        
+        Returns:
+            Task handler callable or None if not found
+        """
+        if version:
+            # Explicit version requested
+            task_key = f"{task_name}:{version}"
+            return self._tasks.get(task_key)
+        else:
+            # No version specified, return latest
+            if task_name in self._latest_versions:
+                latest_version = self._latest_versions[task_name]
+                task_key = f"{task_name}:{latest_version}"
+                return self._tasks.get(task_key)
+            return None
+    
+    def list_tasks(self) -> List[str]:
+        """List all registered task keys (with versions)"""
+        return sorted(self._tasks.keys())
+    
+    def list_task_names(self) -> List[str]:
+        """List unique task names (without versions)"""
+        return sorted(set(self._latest_versions.keys()))
+    
+    def get_task_versions(self, task_name: str) -> List[str]:
+        """Get all registered versions for a task"""
+        versions = []
+        for key in self._tasks.keys():
+            if key.startswith(f"{task_name}:"):
+                version = key.split(":", 1)[1]
+                versions.append(version)
+        return sorted(versions)
+    
+    def has_task(self, task_name: str, version: Optional[str] = None) -> bool:
+        """Check if a task is registered"""
+        if version:
+            task_key = f"{task_name}:{version}"
+            return task_key in self._tasks
+        else:
+            return task_name in self._latest_versions
+    
+    def get_metadata(self, task_name: str, version: Optional[str] = None) -> Optional[Dict]:
+        """Get metadata for a task"""
+        if version:
+            task_key = f"{task_name}:{version}"
+        elif task_name in self._latest_versions:
+            task_key = f"{task_name}:{self._latest_versions[task_name]}"
+        else:
+            return None
+        return self._task_metadata.get(task_key)
+
+
+# Global registry instance
+task_registry = TaskRegistry()

package/gateway/core/semver_classifier.py

@@ -0,0 +1,152 @@
+"""
+Delimit Semver Classifier
+
+Deterministic semver bump classification from diff engine output.
+Takes a list of Change objects and returns the recommended version bump.
+
+Rules:
+  - Any breaking change → MAJOR
+  - Any additive change (no breaking) → MINOR
+  - Non-functional changes only → PATCH
+  - No changes → NONE
+"""
+
+from enum import Enum
+from typing import Any, Dict, List
+
+from .diff_engine_v2 import Change, ChangeType
+
+
+class SemverBump(Enum):
+    NONE = "none"
+    PATCH = "patch"
+    MINOR = "minor"
+    MAJOR = "major"
+
+
+# ── Change-type buckets ──────────────────────────────────────────────
+
+BREAKING_TYPES = frozenset({
+    ChangeType.ENDPOINT_REMOVED,
+    ChangeType.METHOD_REMOVED,
+    ChangeType.REQUIRED_PARAM_ADDED,
+    ChangeType.PARAM_REMOVED,
+    ChangeType.RESPONSE_REMOVED,
+    ChangeType.REQUIRED_FIELD_ADDED,
+    ChangeType.FIELD_REMOVED,
+    ChangeType.TYPE_CHANGED,
+    ChangeType.FORMAT_CHANGED,
+    ChangeType.ENUM_VALUE_REMOVED,
+})
+
+ADDITIVE_TYPES = frozenset({
+    ChangeType.ENDPOINT_ADDED,
+    ChangeType.METHOD_ADDED,
+    ChangeType.OPTIONAL_PARAM_ADDED,
+    ChangeType.RESPONSE_ADDED,
+    ChangeType.OPTIONAL_FIELD_ADDED,
+    ChangeType.ENUM_VALUE_ADDED,
+})
+
+PATCH_TYPES = frozenset({
+    ChangeType.DESCRIPTION_CHANGED,
+})
+
+
+def classify(changes: List[Change]) -> SemverBump:
+    """Classify a list of changes into a semver bump level.
+
+    Deterministic: same input always produces same output.
+    """
+    if not changes:
+        return SemverBump.NONE
+
+    has_breaking = False
+    has_additive = False
+
+    for change in changes:
+        if change.type in BREAKING_TYPES:
+            has_breaking = True
+            break  # short-circuit — can't go higher than MAJOR
+        if change.type in ADDITIVE_TYPES:
+            has_additive = True
+
+    if has_breaking:
+        return SemverBump.MAJOR
+    if has_additive:
+        return SemverBump.MINOR
+    return SemverBump.PATCH
+
+
+def classify_detailed(changes: List[Change]) -> Dict[str, Any]:
+    """Return a detailed classification with per-category breakdowns.
+
+    Used by CLI explain and PR comment generation.
+    """
+    bump = classify(changes)
+
+    breaking = [c for c in changes if c.type in BREAKING_TYPES]
+    additive = [c for c in changes if c.type in ADDITIVE_TYPES]
+    patch = [c for c in changes if c.type in PATCH_TYPES]
+
+    return {
+        "bump": bump.value,
+        "is_breaking": bump == SemverBump.MAJOR,
+        "counts": {
+            "total": len(changes),
+            "breaking": len(breaking),
+            "additive": len(additive),
+            "patch": len(patch),
+        },
+        "breaking_changes": [
+            {"type": c.type.value, "path": c.path, "message": c.message}
+            for c in breaking
+        ],
+        "additive_changes": [
+            {"type": c.type.value, "path": c.path, "message": c.message}
+            for c in additive
+        ],
+        "patch_changes": [
+            {"type": c.type.value, "path": c.path, "message": c.message}
+            for c in patch
+        ],
+    }
+
+
+def bump_version(current: str, bump: SemverBump) -> str:
+    """Apply a semver bump to a version string.
+
+    Args:
+        current: Version string like "1.2.3" or "v1.2.3".
+        bump: The bump level to apply.
+
+    Returns:
+        New version string (preserves 'v' prefix if present).
+    """
+    prefix = ""
+    ver = current
+    if ver.startswith("v"):
+        prefix = "v"
+        ver = ver[1:]
+
+    parts = ver.split(".")
+    if len(parts) != 3:
+        return current  # can't parse — return unchanged
+
+    try:
+        major, minor, patch = int(parts[0]), int(parts[1]), int(parts[2])
+    except ValueError:
+        return current
+
+    if bump == SemverBump.MAJOR:
+        major += 1
+        minor = 0
+        patch = 0
+    elif bump == SemverBump.MINOR:
+        minor += 1
+        patch = 0
+    elif bump == SemverBump.PATCH:
+        patch += 1
+    # NONE: no change
+
+    return f"{prefix}{major}.{minor}.{patch}"

package/gateway/core/spec_detector.py

@@ -0,0 +1,130 @@
+"""
+Automatic OpenAPI specification detector for zero-config installation.
+"""
+
+import os
+from typing import List, Optional, Tuple
+from pathlib import Path
+import yaml
+
+class SpecDetector:
+    """Auto-detect OpenAPI specifications in common locations."""
+    
+    COMMON_SPEC_PATTERNS = [
+        "openapi.yaml",
+        "openapi.yml", 
+        "swagger.yaml",
+        "swagger.yml",
+        "api/openapi.yaml",
+        "api/openapi.yml",
+        "api/swagger.yaml",
+        "api/swagger.yml",
+        "spec/openapi.yaml",
+        "spec/openapi.yml",
+        "docs/openapi.yaml",
+        "docs/api.yaml",
+        "api-spec.yaml",
+        "api-spec.yml",
+        "**/openapi.yaml",  # Recursive search
+        "**/swagger.yaml",
+        "services/*/api/openapi.yaml",  # Monorepo pattern
+    ]
+    
+    def __init__(self, root_path: str = "."):
+        self.root = Path(root_path)
+    
+    def detect_specs(self) -> Tuple[List[str], Optional[str]]:
+        """
+        Detect OpenAPI specifications.
+        
+        Returns:
+            (spec_files, message): List of found specs and optional message
+        """
+        found_specs = []
+        
+        # Check each common pattern
+        for pattern in self.COMMON_SPEC_PATTERNS:
+            if "**" in pattern:
+                # Recursive glob
+                for spec_file in self.root.glob(pattern):
+                    if self._is_valid_openapi(spec_file):
+                        found_specs.append(str(spec_file.relative_to(self.root)))
+            elif "*" in pattern:
+                # Simple glob
+                for spec_file in self.root.glob(pattern):
+                    if self._is_valid_openapi(spec_file):
+                        found_specs.append(str(spec_file.relative_to(self.root)))
+            else:
+                # Direct path
+                spec_file = self.root / pattern
+                if spec_file.exists() and self._is_valid_openapi(spec_file):
+                    found_specs.append(pattern)
+        
+        # Remove duplicates while preserving order
+        found_specs = list(dict.fromkeys(found_specs))
+        
+        # Generate appropriate message
+        if len(found_specs) == 0:
+            message = "No OpenAPI specifications found. Please specify 'files' or create openapi.yaml"
+        elif len(found_specs) == 1:
+            message = f"Auto-detected spec: {found_specs[0]}"
+        else:
+            message = f"Multiple specs found: {', '.join(found_specs[:3])}. Please specify 'files' parameter."
+        
+        return found_specs, message
+    
+    def _is_valid_openapi(self, file_path: Path) -> bool:
+        """Check if file is a valid OpenAPI specification."""
+        if not file_path.is_file():
+            return False
+        
+        try:
+            with open(file_path, 'r') as f:
+                data = yaml.safe_load(f)
+                # Check for OpenAPI/Swagger markers
+                if isinstance(data, dict):
+                    return 'openapi' in data or 'swagger' in data
+        except:
+            return False
+        
+        return False
+    
+    def get_default_specs(self) -> Tuple[Optional[str], Optional[str]]:
+        """
+        Get default old_spec and new_spec for auto-detection.
+        
+        Returns:
+            (old_spec, new_spec): Paths or None if not found
+        """
+        specs, _ = self.detect_specs()
+        
+        if len(specs) == 0:
+            return None, None
+        
+        # Use the first found spec as both old and new (baseline mode)
+        default_spec = specs[0]
+        return default_spec, default_spec
+
+
+def auto_detect_specs(root_path: str = ".") -> dict:
+    """
+    Main entry point for spec auto-detection.
+    
+    Returns dict with:
+        - detected: List of detected spec files
+        - old_spec: Suggested old spec path
+        - new_spec: Suggested new spec path  
+        - message: User-friendly message
+        - requires_input: Whether user must specify paths
+    """
+    detector = SpecDetector(root_path)
+    specs, message = detector.detect_specs()
+    old_spec, new_spec = detector.get_default_specs()
+    
+    return {
+        "detected": specs,
+        "old_spec": old_spec,
+        "new_spec": new_spec,
+        "message": message,
+        "requires_input": len(specs) != 1
+    }