empathy-framework 5.3.0__py3-none-any.whl → 5.4.0__py3-none-any.whl

empathy_os/validation/xml_validator.py

@@ -1,281 +0,0 @@
-"""XML validation for response verification.
-
-Validates XML-structured responses with graceful fallbacks.
-
-Copyright 2026 Smart-AI-Memory
-Licensed under Fair Source License 0.9
-"""
-
-import xml.etree.ElementTree as ET
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Any
-
-
-@dataclass
-class ValidationResult:
-    """Result of XML validation.
-
-    Attributes:
-        is_valid: Whether XML is valid
-        error_message: Error message if invalid
-        parsed_data: Parsed data if valid
-        fallback_used: Whether fallback parsing was used
-    """
-
-    is_valid: bool
-    error_message: str | None = None
-    parsed_data: dict[str, Any] | None = None
-    fallback_used: bool = False
-
-
-class XMLValidator:
-    """Validates XML responses with graceful fallbacks.
-
-    Supports:
-    - Well-formedness validation
-    - XSD schema validation (optional)
-    - Graceful fallback on validation errors
-    - Schema caching for performance
-
-    Usage:
-        validator = XMLValidator()
-        result = validator.validate("<thinking>...</thinking>")
-
-        if result.is_valid:
-            data = result.parsed_data
-        else:
-            # Use fallback parsing
-            data = fallback_parse(response)
-    """
-
-    def __init__(
-        self,
-        schema_dir: str = ".empathy/schemas",
-        strict: bool = False,
-        enable_xsd: bool = False,
-    ):
-        """Initialize validator.
-
-        Args:
-            schema_dir: Directory containing XSD schemas
-            strict: If True, fail on validation errors. If False, use fallback.
-            enable_xsd: Enable XSD schema validation (requires lxml)
-        """
-        self.schema_dir = Path(schema_dir)
-        self.strict = strict
-        self.enable_xsd = enable_xsd
-        self._schema_cache: dict[str, Any] = {}
-
-        # Try to import lxml for XSD validation
-        self._lxml_available = False
-        if enable_xsd:
-            try:
-                from lxml import etree as lxml_etree  # noqa: F401
-
-                self._lxml_available = True
-            except ImportError:
-                pass
-
-    def validate(self, xml_string: str, schema_name: str | None = None) -> ValidationResult:
-        """Validate XML string.
-
-        Args:
-            xml_string: XML content to validate
-            schema_name: Optional XSD schema name (e.g., "agent_response")
-
-        Returns:
-            ValidationResult with validation status and parsed data
-        """
-        # Step 1: Well-formedness validation
-        try:
-            root = ET.fromstring(xml_string)  # nosec B314 - parsing trusted LLM responses
-        except ET.ParseError as e:
-            if self.strict:
-                return ValidationResult(
-                    is_valid=False,
-                    error_message=f"XML parsing failed: {e}",
-                    fallback_used=False,
-                )
-            # Try fallback parsing
-            return self._fallback_parse(xml_string, str(e))
-
-        # Step 2: XSD schema validation (optional)
-        if schema_name and self.enable_xsd and self._lxml_available:
-            schema_result = self._validate_with_xsd(xml_string, schema_name)
-            if not schema_result.is_valid:
-                if self.strict:
-                    return schema_result
-                # Continue with parsed data despite schema error
-                return ValidationResult(
-                    is_valid=True,
-                    parsed_data=self._extract_data(root),
-                    fallback_used=True,
-                    error_message=f"Schema validation failed: {schema_result.error_message}",
-                )
-
-        # Step 3: Extract structured data
-        parsed_data = self._extract_data(root)
-
-        return ValidationResult(
-            is_valid=True,
-            parsed_data=parsed_data,
-            fallback_used=False,
-        )
-
-    def _validate_with_xsd(self, xml_string: str, schema_name: str) -> ValidationResult:
-        """Validate XML against XSD schema.
-
-        Args:
-            xml_string: XML content
-            schema_name: Schema file name (without .xsd extension)
-
-        Returns:
-            ValidationResult
-        """
-        if not self._lxml_available:
-            return ValidationResult(
-                is_valid=False,
-                error_message="lxml not available for XSD validation",
-            )
-
-        try:
-            from lxml import etree as lxml_etree
-        except ImportError:
-            return ValidationResult(
-                is_valid=False,
-                error_message="lxml import failed",
-            )
-
-        # Load schema
-        schema_path = self.schema_dir / f"{schema_name}.xsd"
-        if not schema_path.exists():
-            return ValidationResult(
-                is_valid=False,
-                error_message=f"Schema not found: {schema_path}",
-            )
-
-        # Check cache
-        if schema_name not in self._schema_cache:
-            try:
-                schema_doc = lxml_etree.parse(str(schema_path))
-                self._schema_cache[schema_name] = lxml_etree.XMLSchema(schema_doc)
-            except Exception as e:
-                return ValidationResult(
-                    is_valid=False,
-                    error_message=f"Schema loading failed: {e}",
-                )
-
-        schema = self._schema_cache[schema_name]
-
-        # Validate
-        try:
-            xml_doc = lxml_etree.fromstring(xml_string.encode("utf-8"))
-            is_valid = schema.validate(xml_doc)
-
-            if not is_valid:
-                error_log = schema.error_log
-                return ValidationResult(
-                    is_valid=False,
-                    error_message=f"Schema validation failed: {error_log}",
-                )
-
-            return ValidationResult(is_valid=True)
-
-        except Exception as e:
-            return ValidationResult(
-                is_valid=False,
-                error_message=f"Validation error: {e}",
-            )
-
-    def _fallback_parse(self, xml_string: str, error: str) -> ValidationResult:
-        """Attempt fallback parsing of malformed XML.
-
-        Args:
-            xml_string: XML string that failed to parse
-            error: Parse error message
-
-        Returns:
-            ValidationResult with fallback data
-        """
-        # Try to extract data using regex patterns
-        import re
-
-        data: dict[str, Any] = {}
-
-        # Extract thinking content
-        thinking_match = re.search(r"<thinking[^>]*>(.*?)</thinking>", xml_string, re.DOTALL)
-        if thinking_match:
-            data["thinking"] = thinking_match.group(1).strip()
-
-        # Extract answer content
-        answer_match = re.search(r"<answer[^>]*>(.*?)</answer>", xml_string, re.DOTALL)
-        if answer_match:
-            data["answer"] = answer_match.group(1).strip()
-
-        # If we extracted something, consider it a partial success
-        if data:
-            return ValidationResult(
-                is_valid=True,
-                parsed_data=data,
-                fallback_used=True,
-                error_message=f"XML parsing failed, used fallback: {error}",
-            )
-
-        # Complete failure
-        return ValidationResult(
-            is_valid=False,
-            error_message=f"XML parsing and fallback failed: {error}",
-            fallback_used=True,
-        )
-
-    def _extract_data(self, root: ET.Element) -> dict[str, Any]:
-        """Extract structured data from parsed XML.
-
-        Args:
-            root: Parsed XML root element
-
-        Returns:
-            Dictionary with extracted data
-        """
-        data: dict[str, Any] = {}
-
-        # Extract all child elements
-        for child in root:
-            # Handle nested elements
-            if len(child):
-                data[child.tag] = self._extract_data(child)
-            else:
-                # Leaf node - get text content
-                data[child.tag] = child.text if child.text else ""
-
-        # Also store root attributes
-        if root.attrib:
-            data["_attributes"] = dict(root.attrib)
-
-        return data
-
-
-def validate_xml_response(
-    response: str,
-    schema_name: str | None = None,
-    strict: bool = False,
-) -> ValidationResult:
-    """Convenience function to validate XML response.
-
-    Args:
-        response: XML response string
-        schema_name: Optional XSD schema name
-        strict: If True, fail on validation errors
-
-    Returns:
-        ValidationResult
-
-    Example:
-        >>> response = "<thinking>Analysis</thinking><answer>Result</answer>"
-        >>> result = validate_xml_response(response)
-        >>> if result.is_valid:
-        ...     print(result.parsed_data)
-    """
-    validator = XMLValidator(strict=strict)
-    return validator.validate(response, schema_name)

empathy_os/vscode_bridge.py

@@ -1,173 +0,0 @@
-"""VS Code Extension Bridge
-
-Provides functions to write data that the VS Code extension can pick up.
-Enables Claude Code CLI output to appear in VS Code webview panels.
-
-Copyright 2026 Smart-AI-Memory
-Licensed under Fair Source License 0.9
-"""
-
-import json
-from dataclasses import asdict, dataclass
-from datetime import datetime
-from pathlib import Path
-from typing import Any
-
-
-@dataclass
-class ReviewFinding:
-    """A code review finding."""
-
-    id: str
-    file: str
-    line: int
-    severity: str  # 'critical' | 'high' | 'medium' | 'low' | 'info'
-    category: str  # 'security' | 'performance' | 'maintainability' | 'style' | 'correctness'
-    message: str
-    column: int = 1
-    details: str | None = None
-    recommendation: str | None = None
-
-
-@dataclass
-class CodeReviewResult:
-    """Code review results for VS Code bridge."""
-
-    findings: list[dict[str, Any]]
-    summary: dict[str, Any]
-    verdict: str  # 'approve' | 'approve_with_suggestions' | 'request_changes' | 'reject'
-    security_score: int
-    formatted_report: str
-    model_tier_used: str
-    timestamp: str
-
-
-def get_empathy_dir() -> Path:
-    """Get the .empathy directory, creating if needed."""
-    empathy_dir = Path(".empathy")
-    empathy_dir.mkdir(exist_ok=True)
-    return empathy_dir
-
-
-def write_code_review_results(
-    findings: list[dict[str, Any]] | None = None,
-    summary: dict[str, Any] | None = None,
-    verdict: str = "approve_with_suggestions",
-    security_score: int = 85,
-    formatted_report: str = "",
-    model_tier_used: str = "capable",
-) -> Path:
-    """Write code review results for VS Code extension to pick up.
-
-    Args:
-        findings: List of finding dicts with keys: id, file, line, severity, category, message
-        summary: Summary dict with keys: total_findings, by_severity, by_category, files_affected
-        verdict: One of 'approve', 'approve_with_suggestions', 'request_changes', 'reject'
-        security_score: 0-100 score
-        formatted_report: Markdown formatted report
-        model_tier_used: 'cheap', 'capable', or 'premium'
-
-    Returns:
-        Path to the written file
-    """
-    findings = findings or []
-
-    # Build summary if not provided
-    if summary is None:
-        by_severity: dict[str, int] = {}
-        by_category: dict[str, int] = {}
-        files_affected: set[str] = set()
-
-        for f in findings:
-            sev = f.get("severity", "info")
-            cat = f.get("category", "correctness")
-            by_severity[sev] = by_severity.get(sev, 0) + 1
-            by_category[cat] = by_category.get(cat, 0) + 1
-            if f.get("file"):
-                files_affected.add(f["file"])
-
-        summary = {
-            "total_findings": len(findings),
-            "by_severity": by_severity,
-            "by_category": by_category,
-            "files_affected": list(files_affected),
-        }
-
-    result = CodeReviewResult(
-        findings=findings,
-        summary=summary,
-        verdict=verdict,
-        security_score=security_score,
-        formatted_report=formatted_report,
-        model_tier_used=model_tier_used,
-        timestamp=datetime.now().isoformat(),
-    )
-
-    output_path = get_empathy_dir() / "code-review-results.json"
-
-    with open(output_path, "w") as f:
-        json.dump(asdict(result), f, indent=2)
-
-    return output_path
-
-
-def write_pr_review_results(
-    pr_number: int | str,
-    title: str,
-    findings: list[dict[str, Any]],
-    verdict: str = "approve_with_suggestions",
-    summary_text: str = "",
-) -> Path:
-    """Write PR review results for VS Code extension.
-
-    Convenience wrapper for PR reviews from GitHub.
-
-    Args:
-        pr_number: The PR number
-        title: PR title
-        findings: List of review findings
-        verdict: Review verdict
-        summary_text: Summary of the review
-
-    Returns:
-        Path to the written file
-    """
-    formatted_report = f"""## PR #{pr_number}: {title}
-
-{summary_text}
-
-### Findings ({len(findings)})
-
-"""
-    for f in findings:
-        formatted_report += f"- **{f.get('severity', 'info').upper()}** [{f.get('file', 'unknown')}:{f.get('line', 0)}]: {f.get('message', '')}\n"
-
-    return write_code_review_results(
-        findings=findings,
-        verdict=verdict,
-        formatted_report=formatted_report,
-        model_tier_used="capable",
-    )
-
-
-# Quick helper for Claude Code to call
-def send_to_vscode(
-    message: str,
-    findings: list[dict[str, Any]] | None = None,
-    verdict: str = "approve_with_suggestions",
-) -> str:
-    """Quick helper to send review results to VS Code.
-
-    Usage in Claude Code:
-        from empathy_os.vscode_bridge import send_to_vscode
-        send_to_vscode("Review complete", findings=[...])
-
-    Returns:
-        Confirmation message
-    """
-    path = write_code_review_results(
-        findings=findings or [],
-        formatted_report=message,
-        verdict=verdict,
-    )
-    return f"Results written to {path} - VS Code will update automatically"