tapps-agents 3.5.40__py3-none-any.whl → 3.6.0__py3-none-any.whl

tapps_agents/core/validation_registry.py

@@ -1,136 +1,136 @@
-"""
-Validation registry for pluggable validators.
-
-Auto-detects validators based on project profile and loads them.
-"""
-
-import logging
-from pathlib import Path
-from typing import Any
-
-from .evaluation_base import BaseValidator
-from .project_profile import ProjectProfile
-
-logger = logging.getLogger(__name__)
-
-
-class ValidationRegistry:
-    """
-    Registry for project-specific validators.
-    
-    Auto-detects validators based on project profile and loads them.
-    """
-
-    def __init__(self, project_root: Path | None = None):
-        """
-        Initialize validation registry.
-        
-        Args:
-            project_root: Project root directory
-        """
-        self.project_root = project_root or Path.cwd()
-        self.validators: dict[str, BaseValidator] = {}
-        self.project_profile: ProjectProfile | None = None
-
-    def load_project_profile(self, profile_path: Path | None = None) -> None:
-        """
-        Load project profile for validator detection.
-        
-        Args:
-            profile_path: Optional path to project-profile.yaml
-        """
-        if profile_path is None:
-            profile_path = self.project_root / ".tapps-agents" / "project-profile.yaml"
-        
-        if profile_path.exists():
-            try:
-                self.project_profile = ProjectProfile.load(profile_path)
-            except Exception as e:
-                logger.warning(f"Failed to load project profile: {e}")
-        else:
-            # Create default profile
-            self.project_profile = ProjectProfile()
-
-    def detect_validators(self) -> list[str]:
-        """
-        Detect applicable validators from project profile.
-        
-        Returns:
-            List of validator identifiers
-        """
-        if self.project_profile is None:
-            self.load_project_profile()
-        
-        detected: list[str] = []
-        
-        # Detect by language
-        languages = self.project_profile.languages if self.project_profile else []
-        if "python" in languages:
-            detected.append("python")
-        if "typescript" in languages or "javascript" in languages:
-            detected.append("typescript")
-        
-        # Detect by frameworks/tools
-        frameworks = self.project_profile.frameworks if self.project_profile else []
-        if any("docker" in f.lower() for f in frameworks):
-            detected.append("docker")
-        if any("ci" in f.lower() or "github" in f.lower() for f in frameworks):
-            detected.append("ci")
-        
-        return detected
-
-    def register_validator(self, validator: BaseValidator) -> None:
-        """
-        Register a validator.
-        
-        Args:
-            validator: Validator instance
-        """
-        self.validators[validator.get_name()] = validator
-        logger.debug(f"Registered validator: {validator.get_name()}")
-
-    def get_validators(self, project_profile: dict[str, Any] | None = None) -> list[BaseValidator]:
-        """
-        Get validators applicable to project.
-        
-        Args:
-            project_profile: Optional project profile dict
-            
-        Returns:
-            List of applicable validators
-        """
-        if not project_profile and self.project_profile:
-            project_profile = self.project_profile.to_dict()
-        
-        applicable = []
-        for validator in self.validators.values():
-            if validator.is_applicable(project_profile or {}):
-                applicable.append(validator)
-        
-        return applicable
-
-    def validate(
-        self, target: Path | str, project_profile: dict[str, Any] | None = None
-    ) -> list[Any]:
-        """
-        Run all applicable validators on target.
-        
-        Args:
-            target: File path or identifier to validate
-            project_profile: Optional project profile
-            
-        Returns:
-            List of ValidationResult objects
-        """
-        validators = self.get_validators(project_profile)
-        results = []
-        
-        for validator in validators:
-            try:
-                result = validator.validate(target, project_profile)
-                results.append(result)
-            except Exception as e:
-                logger.warning(f"Error in validator {validator.get_name()}: {e}")
-        
-        return results
-
+"""
+Validation registry for pluggable validators.
+
+Auto-detects validators based on project profile and loads them.
+"""
+
+import logging
+from pathlib import Path
+from typing import Any
+
+from .evaluation_base import BaseValidator
+from .project_profile import ProjectProfile
+
+logger = logging.getLogger(__name__)
+
+
+class ValidationRegistry:
+    """
+    Registry for project-specific validators.
+    
+    Auto-detects validators based on project profile and loads them.
+    """
+
+    def __init__(self, project_root: Path | None = None):
+        """
+        Initialize validation registry.
+        
+        Args:
+            project_root: Project root directory
+        """
+        self.project_root = project_root or Path.cwd()
+        self.validators: dict[str, BaseValidator] = {}
+        self.project_profile: ProjectProfile | None = None
+
+    def load_project_profile(self, profile_path: Path | None = None) -> None:
+        """
+        Load project profile for validator detection.
+        
+        Args:
+            profile_path: Optional path to project-profile.yaml
+        """
+        if profile_path is None:
+            profile_path = self.project_root / ".tapps-agents" / "project-profile.yaml"
+        
+        if profile_path.exists():
+            try:
+                self.project_profile = ProjectProfile.load(profile_path)
+            except Exception as e:
+                logger.warning(f"Failed to load project profile: {e}")
+        else:
+            # Create default profile
+            self.project_profile = ProjectProfile()
+
+    def detect_validators(self) -> list[str]:
+        """
+        Detect applicable validators from project profile.
+        
+        Returns:
+            List of validator identifiers
+        """
+        if self.project_profile is None:
+            self.load_project_profile()
+        
+        detected: list[str] = []
+        
+        # Detect by language
+        languages = self.project_profile.languages if self.project_profile else []
+        if "python" in languages:
+            detected.append("python")
+        if "typescript" in languages or "javascript" in languages:
+            detected.append("typescript")
+        
+        # Detect by frameworks/tools
+        frameworks = self.project_profile.frameworks if self.project_profile else []
+        if any("docker" in f.lower() for f in frameworks):
+            detected.append("docker")
+        if any("ci" in f.lower() or "github" in f.lower() for f in frameworks):
+            detected.append("ci")
+        
+        return detected
+
+    def register_validator(self, validator: BaseValidator) -> None:
+        """
+        Register a validator.
+        
+        Args:
+            validator: Validator instance
+        """
+        self.validators[validator.get_name()] = validator
+        logger.debug(f"Registered validator: {validator.get_name()}")
+
+    def get_validators(self, project_profile: dict[str, Any] | None = None) -> list[BaseValidator]:
+        """
+        Get validators applicable to project.
+        
+        Args:
+            project_profile: Optional project profile dict
+            
+        Returns:
+            List of applicable validators
+        """
+        if not project_profile and self.project_profile:
+            project_profile = self.project_profile.to_dict()
+        
+        applicable = []
+        for validator in self.validators.values():
+            if validator.is_applicable(project_profile or {}):
+                applicable.append(validator)
+        
+        return applicable
+
+    def validate(
+        self, target: Path | str, project_profile: dict[str, Any] | None = None
+    ) -> list[Any]:
+        """
+        Run all applicable validators on target.
+        
+        Args:
+            target: File path or identifier to validate
+            project_profile: Optional project profile
+            
+        Returns:
+            List of ValidationResult objects
+        """
+        validators = self.get_validators(project_profile)
+        results = []
+        
+        for validator in validators:
+            try:
+                result = validator.validate(target, project_profile)
+                results.append(result)
+            except Exception as e:
+                logger.warning(f"Error in validator {validator.get_name()}: {e}")
+        
+        return results
+

tapps_agents/core/validators/__init__.py

@@ -1,4 +1,4 @@
-"""
-Pluggable validators for project-specific validation.
-"""
-
+"""
+Pluggable validators for project-specific validation.
+"""
+

tapps_agents/core/validators/python_validator.py

@@ -1,87 +1,87 @@
-"""
-Python-specific validator.
-"""
-
-import logging
-from pathlib import Path
-from typing import Any
-
-from ..evaluation_base import BaseValidator, ValidationResult
-from ..evaluation_models import Issue, IssueCategory, IssueManifest, IssueSeverity
-
-logger = logging.getLogger(__name__)
-
-
-class PythonValidator(BaseValidator):
-    """Validator for Python-specific checks."""
-
-    def get_name(self) -> str:
-        """Get validator name."""
-        return "python"
-
-    def get_description(self) -> str:
-        """Get validator description."""
-        return "Validates Python-specific coding standards and best practices"
-
-    def is_applicable(self, project_profile: dict[str, Any]) -> bool:
-        """Check if validator is applicable to project."""
-        languages = project_profile.get("languages", [])
-        return "python" in languages
-
-    def validate(
-        self, target: Path | str, context: dict[str, Any] | None = None
-    ) -> ValidationResult:
-        """
-        Validate Python file.
-        
-        Args:
-            target: File path to validate
-            context: Optional context
-            
-        Returns:
-            ValidationResult
-        """
-        target_path = Path(target) if isinstance(target, str) else target
-        issues = IssueManifest()
-        
-        if not target_path.exists() or target_path.suffix != ".py":
-            return ValidationResult(passed=True, issues=issues)
-        
-        try:
-            code = target_path.read_text(encoding="utf-8")
-            
-            # Check for Python-specific issues
-            # Missing docstrings
-            if "def " in code and not '"""' in code[:500] and not "'''" in code[:500]:
-                issue = Issue(
-                    id=f"python_missing_docstring_{target_path.name}",
-                    severity=IssueSeverity.LOW,
-                    category=IssueCategory.DOCUMENTATION,
-                    evidence="File appears to have functions but no module docstring",
-                    repro=f"Review {target_path} for docstrings",
-                    suggested_fix="Add module and function docstrings",
-                    owner_step="implementation",
-                    file_path=str(target_path),
-                )
-                issues.add_issue(issue)
-            
-            # Check for common Python issues
-            if "import *" in code:
-                issue = Issue(
-                    id=f"python_wildcard_import_{target_path.name}",
-                    severity=IssueSeverity.MEDIUM,
-                    category=IssueCategory.MAINTAINABILITY,
-                    evidence="Wildcard import (import *) found",
-                    repro=f"Check imports in {target_path}",
-                    suggested_fix="Replace wildcard imports with explicit imports",
-                    owner_step="implementation",
-                    file_path=str(target_path),
-                )
-                issues.add_issue(issue)
-        
-        except Exception as e:
-            logger.warning(f"Error in Python validation: {e}")
-        
-        passed = len(issues.issues) == 0
-        return ValidationResult(passed=passed, issues=issues)
-
+"""
+Python-specific validator.
+"""
+
+import logging
+from pathlib import Path
+from typing import Any
+
+from ..evaluation_base import BaseValidator, ValidationResult
+from ..evaluation_models import Issue, IssueCategory, IssueManifest, IssueSeverity
+
+logger = logging.getLogger(__name__)
+
+
+class PythonValidator(BaseValidator):
+    """Validator for Python-specific checks."""
+
+    def get_name(self) -> str:
+        """Get validator name."""
+        return "python"
+
+    def get_description(self) -> str:
+        """Get validator description."""
+        return "Validates Python-specific coding standards and best practices"
+
+    def is_applicable(self, project_profile: dict[str, Any]) -> bool:
+        """Check if validator is applicable to project."""
+        languages = project_profile.get("languages", [])
+        return "python" in languages
+
+    def validate(
+        self, target: Path | str, context: dict[str, Any] | None = None
+    ) -> ValidationResult:
+        """
+        Validate Python file.
+        
+        Args:
+            target: File path to validate
+            context: Optional context
+            
+        Returns:
+            ValidationResult
+        """
+        target_path = Path(target) if isinstance(target, str) else target
+        issues = IssueManifest()
+        
+        if not target_path.exists() or target_path.suffix != ".py":
+            return ValidationResult(passed=True, issues=issues)
+        
+        try:
+            code = target_path.read_text(encoding="utf-8")
+            
+            # Check for Python-specific issues
+            # Missing docstrings
+            if "def " in code and not '"""' in code[:500] and not "'''" in code[:500]:
+                issue = Issue(
+                    id=f"python_missing_docstring_{target_path.name}",
+                    severity=IssueSeverity.LOW,
+                    category=IssueCategory.DOCUMENTATION,
+                    evidence="File appears to have functions but no module docstring",
+                    repro=f"Review {target_path} for docstrings",
+                    suggested_fix="Add module and function docstrings",
+                    owner_step="implementation",
+                    file_path=str(target_path),
+                )
+                issues.add_issue(issue)
+            
+            # Check for common Python issues
+            if "import *" in code:
+                issue = Issue(
+                    id=f"python_wildcard_import_{target_path.name}",
+                    severity=IssueSeverity.MEDIUM,
+                    category=IssueCategory.MAINTAINABILITY,
+                    evidence="Wildcard import (import *) found",
+                    repro=f"Check imports in {target_path}",
+                    suggested_fix="Replace wildcard imports with explicit imports",
+                    owner_step="implementation",
+                    file_path=str(target_path),
+                )
+                issues.add_issue(issue)
+        
+        except Exception as e:
+            logger.warning(f"Error in Python validation: {e}")
+        
+        passed = len(issues.issues) == 0
+        return ValidationResult(passed=passed, issues=issues)
+

tapps_agents/core/verification_agent.py

@@ -1,90 +1,90 @@
-"""
-Collaborative Verification Agents
-
-Verification and refinement agents without manual prompts.
-"""
-
-import logging
-from typing import Any
-
-logger = logging.getLogger(__name__)
-
-
-class VerificationAgent:
-    """Verification agent that examines outputs at each step."""
-
-    def verify(self, output: Any, requirements: dict[str, Any]) -> dict[str, Any]:
-        """
-        Verify output meets requirements.
-
-        Args:
-            output: Output to verify
-            requirements: Requirements to check against (e.g. required_keys, min_length, non_empty)
-
-        Returns:
-            Verification result with verified (bool) and issues (list of str)
-        """
-        issues: list[str] = []
-
-        # Required keys: if requirements has required_keys, output (if dict) must contain them
-        required_keys = requirements.get("required_keys")
-        if isinstance(required_keys, list) and required_keys:
-            if not isinstance(output, dict):
-                issues.append(f"Output must be a dict with keys {required_keys}, got {type(output).__name__}")
-            else:
-                missing = [k for k in required_keys if k not in output]
-                if missing:
-                    issues.append(f"Missing required keys: {missing}")
-
-        # Non-empty: if requirements.get("non_empty") is True, output must be non-empty
-        if requirements.get("non_empty") is True:
-            if output is None:
-                issues.append("Output must be non-empty, got None")
-            elif isinstance(output, (str, list, dict)) and len(output) == 0:
-                issues.append("Output must be non-empty")
-
-        # min_length: for str/list, check length
-        min_len = requirements.get("min_length")
-        if isinstance(min_len, (int, float)) and min_len > 0:
-            if isinstance(output, (str, list)):
-                if len(output) < int(min_len):
-                    issues.append(f"Output length {len(output)} below min_length {min_len}")
-            elif isinstance(output, dict) and len(output) < int(min_len):
-                issues.append(f"Output has {len(output)} keys, below min_length {min_len}")
-
-        return {"verified": len(issues) == 0, "issues": issues}
-
-
-class RefinementAgent:
-    """Refinement agent that revises outputs based on issues."""
-
-    def refine(self, output: Any, issues: list[str]) -> Any:
-        """
-        Refine output based on issues.
-
-        Args:
-            output: Output to refine
-            issues: List of issues to address
-
-        Returns:
-            Refined output (structure preserved; refinements recorded when possible)
-        """
-        if not issues:
-            return output
-
-        # For dict: add a refinement record without mutating semantic content
-        if isinstance(output, dict):
-            out = dict(output)
-            out["_refinement"] = {"issues_addressed": issues, "refined": True}
-            return out
-
-        # For str: append a short refinement note as a comment block
-        if isinstance(output, str):
-            block = "\n\n# Refinement: issues to address: " + "; ".join(issues[:5])
-            if len(issues) > 5:
-                block += f" (+{len(issues) - 5} more)"
-            return output + block
-
-        # For other types, return as-is (refinement would need type-specific logic)
-        return output
-
+"""
+Collaborative Verification Agents
+
+Verification and refinement agents without manual prompts.
+"""
+
+import logging
+from typing import Any
+
+logger = logging.getLogger(__name__)
+
+
+class VerificationAgent:
+    """Verification agent that examines outputs at each step."""
+
+    def verify(self, output: Any, requirements: dict[str, Any]) -> dict[str, Any]:
+        """
+        Verify output meets requirements.
+
+        Args:
+            output: Output to verify
+            requirements: Requirements to check against (e.g. required_keys, min_length, non_empty)
+
+        Returns:
+            Verification result with verified (bool) and issues (list of str)
+        """
+        issues: list[str] = []
+
+        # Required keys: if requirements has required_keys, output (if dict) must contain them
+        required_keys = requirements.get("required_keys")
+        if isinstance(required_keys, list) and required_keys:
+            if not isinstance(output, dict):
+                issues.append(f"Output must be a dict with keys {required_keys}, got {type(output).__name__}")
+            else:
+                missing = [k for k in required_keys if k not in output]
+                if missing:
+                    issues.append(f"Missing required keys: {missing}")
+
+        # Non-empty: if requirements.get("non_empty") is True, output must be non-empty
+        if requirements.get("non_empty") is True:
+            if output is None:
+                issues.append("Output must be non-empty, got None")
+            elif isinstance(output, (str, list, dict)) and len(output) == 0:
+                issues.append("Output must be non-empty")
+
+        # min_length: for str/list, check length
+        min_len = requirements.get("min_length")
+        if isinstance(min_len, (int, float)) and min_len > 0:
+            if isinstance(output, (str, list)):
+                if len(output) < int(min_len):
+                    issues.append(f"Output length {len(output)} below min_length {min_len}")
+            elif isinstance(output, dict) and len(output) < int(min_len):
+                issues.append(f"Output has {len(output)} keys, below min_length {min_len}")
+
+        return {"verified": len(issues) == 0, "issues": issues}
+
+
+class RefinementAgent:
+    """Refinement agent that revises outputs based on issues."""
+
+    def refine(self, output: Any, issues: list[str]) -> Any:
+        """
+        Refine output based on issues.
+
+        Args:
+            output: Output to refine
+            issues: List of issues to address
+
+        Returns:
+            Refined output (structure preserved; refinements recorded when possible)
+        """
+        if not issues:
+            return output
+
+        # For dict: add a refinement record without mutating semantic content
+        if isinstance(output, dict):
+            out = dict(output)
+            out["_refinement"] = {"issues_addressed": issues, "refined": True}
+            return out
+
+        # For str: append a short refinement note as a comment block
+        if isinstance(output, str):
+            block = "\n\n# Refinement: issues to address: " + "; ".join(issues[:5])
+            if len(issues) > 5:
+                block += f" (+{len(issues) - 5} more)"
+            return output + block
+
+        # For other types, return as-is (refinement would need type-specific logic)
+        return output
+