attune-ai 2.0.0__py3-none-any.whl

attune/validation/xml_validator.py

@@ -0,0 +1,281 @@
+"""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 = ".attune/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)

attune/vscode_bridge.py

@@ -0,0 +1,173 @@
+"""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 attune.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"