feat: local PII/Secret detection guard

Author: rahuldass19

qwed_sdk/client.py

@@ -154,6 +154,26 @@ def verify_fact(
     ) -> VerificationResult:
         """Verify a factual claim against context."""
         start = time.time()
+        
+        # Try local PII scanning first (Privacy Safety - Mode B)
+        try:
+            from qwed_new.guards.pii_guard import PIIGuard
+            guard = PIIGuard()
+            # Treat the 'claim' (response) as the content to scan for leaks
+            pii_result = guard.scan(claim)
+            
+            if not pii_result["verified"]:
+                # PII Detected locally - Return immediately
+                return VerificationResult(
+                    status="UNVERIFIED",
+                    is_verified=False,
+                    result=pii_result,
+                    latency_ms=(time.time() - start) * 1000
+                )
+        except ImportError:
+            pass # Fallback to remote if local guard missing
+
+        # Remote verification (if no local PII or Guard missing)
         data = self._request(
             "POST",
             "/verify/fact",

src/qwed_new/guards/pii_guard.py

@@ -0,0 +1,64 @@
+import re
+from typing import Dict, Any, List
+
+class PIIGuard:
+    """
+    Local-first PII and Secret detection using regex heuristics.
+    Lightweight, offline-capable scanner for sensitive data.
+    """
+    
+    def __init__(self):
+        # Pre-compiled regex patterns for performance
+        self.patterns = {
+            "openai_api_key": re.compile(r"sk-(proj-)?[\w-]{20,}"),
+            "anthropic_api_key": re.compile(r"sk-ant-[\w-]{20,}"),
+            "aws_access_key": re.compile(r"(A3T[A-Z0-9]|AKIA|AGPA|AIDA|AROA|AIPA|ANPA|ANVA|ASIA)[A-Z0-9]{16}"),
+            "ssh_private_key": re.compile(r"-----BEGIN (?:RSA|DSA|EC|OPENSSH) PRIVATE KEY-----"),
+            "email": re.compile(r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,7}\b"),
+            # Identifying common password declarations (heuristic)
+            "password_assignment": re.compile(r"(?i)(password|passwd|pwd|secret)\s*[:=]\s*['\"]?(\S{6,})['\"]?"),
+            # Generic high-entropy strings usually associated with secrets (checking later if needed)
+            
+            # Additional PII
+            "phone_number": re.compile(r"(\+\d{1,3}[-.]?)?\(?\d{3}\)?[-.]?\d{3}[-.]?\d{4}"),
+        }
+
+    def scan(self, content: str) -> Dict[str, Any]:
+        """
+        Scans the provided content for secrets and PII.
+        Returns a dictionary with detection results.
+        """
+        detected_types = []
+        violations = []
+        
+        for name, pattern in self.patterns.items():
+            matches = pattern.findall(content)
+            if matches:
+                # Special handling for password heuristic to avoid false positives on simple words
+                if name == "password_assignment":
+                    # matches will be list of tuples (key, value)
+                    # We accept it if the value part looks like a secret
+                    valid_matches = [m for m in matches if len(m[1]) > 5]  # simple length check
+                    if not valid_matches:
+                        continue
+
+                detected_types.append(name)
+                # Redact content for safe logging (showing first few chars only)
+                for m in matches:
+                    snippet = str(m)[:10] + "..." 
+                    violations.append(f"Potential {name} detected: {snippet}")
+
+        if detected_types:
+            return {
+                "verified": False,
+                "risk": "PII_LEAK",
+                "types": detected_types,
+                "violations": violations,
+                "message": f"Secrets detected: {', '.join(detected_types)}"
+            }
+        
+        return {
+            "verified": True,
+            "scan_method": "REGEX_HEURISTICS",
+            "message": "No obvious secrets found."
+        }