Merge branch 'main' of https://huggingface.co/spaces/gaurv007/ClauseGuard

README.md

@@ -9,3 +9,102 @@ python_version: "3.12"
 app_file: app.py
 pinned: false
 ---
+
+# 🛡️ ClauseGuard — World's Best Open-Source Legal Contract Analysis
+
+**ClauseGuard** is the most comprehensive open-source AI-powered legal contract analysis tool. It analyzes contracts using state-of-the-art legal NLP models and provides actionable risk assessments.
+
+## ✨ Core Features
+
+### Analysis Engine
+| Feature | Description |
+|---------|-------------|
+| **41 CUAD Clause Categories** | Full taxonomy: Document Name, Parties, Governing Law, Indemnification, Termination, Non-Compete, IP Ownership, Audit Rights, Force Majeure, and more |
+| **4-Tier Risk Scoring** | Critical 🔴 / High 🟠 / Medium 🟡 / Low 🟢 with visual risk matrix |
+| **Legal NER** | Extracts parties, dates, monetary values ($), jurisdictions, defined terms, and party roles |
+| **NLI Contradiction Detection** | Identifies conflicting clauses (e.g., uncapped + capped liability) and missing critical provisions |
+| **Obligation Tracker** | Categorizes action items: monetary 💰, compliance ⚖️, reporting 📊, delivery 📦, termination 🛑 |
+| **Compliance Checker** | Validates against GDPR, CCPA, SOX, HIPAA, and FINRA requirements |
+| **Contract Comparison** | Side-by-side diff between two contracts with alignment scoring |
+
+### Document Support
+- **PDF** parsing via `pdfplumber`
+- **DOCX/DOC** parsing via `python-docx`
+- **TXT / Markdown** direct text input
+
+### UI/UX
+- **3-Panel Professional Layout** — Upload sidebar + Main analysis + Summary dashboard
+- **Document Viewer** — Inline entity highlights (colored annotations)
+- **Clause Cards** — Expandable risk-badged cards with confidence scores
+- **Export Reports** — JSON (structured) and CSV (tabular) downloads
+- **Color-Coded Risk Badges** — Instant visual triage
+
+## 🧠 Models & Architecture
+
+| Component | Technology |
+|-----------|------------|
+| Clause Classification | `Mokshith31/legalbert-contract-clause-classification` — LoRA adapter on `nlpaueb/legal-bert-base-uncased`, fine-tuned on CUAD 41-class taxonomy |
+| NER | Rule-based with 7 entity types (dates, money, parties, jurisdictions, defined terms) |
+| NLI | Heuristic contradiction detection with 5 conflict patterns + missing-clause detection |
+| Compliance | Regulatory keyword matching across GDPR, CCPA, SOX, HIPAA, FINRA |
+| Comparison | SequenceMatcher-based clause alignment with risk delta analysis |
+| Obligations | Regex pattern matching across 5 obligation categories |
+
+## 📊 Risk Scoring Methodology
+
+Risk scores combine clause detection with weighted severity:
+- **CRITICAL**: 40 pts (Uncapped Liability, Arbitration, IP Assignment, etc.)
+- **HIGH**: 20 pts (Non-Compete, Exclusivity, Unilateral Change, etc.)
+- **MEDIUM**: 10 pts (Governing Law, Jurisdiction, etc.)
+- **LOW**: 3 pts (Document Name, Dates, etc.)
+
+Final score normalized to 0-100 with letter grades:
+- A (0-14): Low risk
+- B (15-29): Moderate risk
+- C (30-49): Elevated risk
+- D (50-69): High risk
+- F (70+): Critical risk
+
+## 📚 Datasets & Research
+
+- [CUAD](https://huggingface.co/datasets/theatticusproject/cuad-qa) — 510 contracts, 13K annotations, 41 clause categories
+- [LegalBench](https://huggingface.co/datasets/nguha/legalbench) — 322 legal reasoning tasks
+- [LexGLUE](https://huggingface.co/datasets/coastalcph/lex_glue) — Unfair Terms of Service classification
+- Paper: [CUAD: An Expert-Annotated NLP Dataset for Legal Contract Review](https://arxiv.org/abs/2103.06268) (Hendrycks et al., 2021)
+
+## 🚀 Usage
+
+1. **Upload** a contract (PDF, DOCX, or TXT) or paste text directly
+2. Click **Analyze Contract**
+3. View results across tabs:
+   - **Document**: Full text with inline entity highlights
+   - **Clauses**: Detected clauses with risk badges
+   - **Entities**: Extracted parties, dates, money, jurisdictions
+   - **Contradictions**: Conflicting clauses and missing provisions
+   - **Obligations**: Action items categorized by type
+   - **Compliance**: Regulatory framework checks
+4. **Export** JSON/CSV reports
+
+## 🔀 Compare Contracts
+
+Switch to the **Compare Contracts** tab to:
+- Upload or paste two contracts side-by-side
+- See clause-level diffs (added, removed, modified)
+- Get an alignment score and risk delta
+- View raw JSON comparison data
+
+## ⚠️ Disclaimer
+
+*Not legal advice. ClauseGuard is an AI-powered analysis tool for informational purposes only. Always consult a qualified attorney for legal decisions. The tool may miss nuances and should be used as a preliminary screening aid, not a substitute for professional legal review.*
+
+## 🔗 Links
+
+- [ClauseGuard Space](https://huggingface.co/spaces/gaurv007/ClauseGuard)
+- [Clause Classifier Model](https://huggingface.co/Mokshith31/legalbert-contract-clause-classification)
+- [Legal-BERT Base](https://huggingface.co/nlpaueb/legal-bert-base-uncased)
+- [CUAD Dataset](https://huggingface.co/datasets/theatticusproject/cuad-qa)
+- [CUAD Paper (arXiv:2103.06268)](https://arxiv.org/abs/2103.06268)
+
+---
+
+*Built with ❤️ using Gradio, Hugging Face Transformers, and Legal-BERT. Open source and free for all.*

app.py

@@ -1,37 +1,327 @@
 """
-ClauseGuard — AI Fine Print Scanner
-Uses Legal-BERT fine-tuned on CLAUDETTE/LexGLUE unfair_tos (8 categories).
+ClauseGuard — World's Best Legal Contract Analysis Tool
+════════════════════════════════════════════════════════
+Features:
+  • 41 CUAD clause categories via fine-tuned Legal-BERT
+  • 4-tier risk scoring (Critical / High / Medium / Low)
+  • Legal NER: parties, dates, monetary values, jurisdictions, defined terms
+  • NLI contradiction & missing-clause detection
+  • Contract comparison engine (diff between 2 contracts)
+  • Obligation tracker (monetary, compliance, reporting, delivery)
+  • Compliance checker (GDPR, CCPA, SOX, HIPAA, FINRA)
+  • PDF / DOCX / TXT parsing
+  • Professional 3-panel Gradio UI
+  • JSON & CSV export
+
+Models:
+  • Clause classifier: Mokshith31/legalbert-contract-clause-classification
+    (LoRA adapter on nlpaueb/legal-bert-base-uncased, 41 CUAD classes)
 """
 
-import gradio as gr
+import os
 import re
+import json
+import csv
+import io
+from collections import defaultdict
+from datetime import datetime
+
+import gradio as gr
 import numpy as np
 
-# ─── Load ML model ───
-MODEL_ID = "gaurv007/clauseguard-legal-bert"
-ml_pipeline = None
+# ── Document parsers (soft-fail) ────────────────────────────────────
+try:
+    import pdfplumber
+    _HAS_PDF = True
+except Exception:
+    _HAS_PDF = False
+
+try:
+    from docx import Document as DocxDocument
+    _HAS_DOCX = True
+except Exception:
+    _HAS_DOCX = False
 
+# ── PyTorch / Transformers (soft-fail) ────────────────────────────────
 try:
-    from transformers import pipeline
-    ml_pipeline = pipeline("text-classification", model=MODEL_ID, top_k=None, device=-1)
-    print(f"Loaded model: {MODEL_ID}")
-except Exception as e:
-    print(f"Model load failed ({e}), using regex fallback")
-
-# ─── Label metadata ───
-LABELS = {
-    "Limitation of liability": ("HIGH", "Company avoids responsibility for damages or losses."),
-    "Unilateral termination": ("HIGH", "They can close your account without reason."),
-    "Unilateral change": ("MEDIUM", "Terms can change without your consent."),
-    "Content removal": ("MEDIUM", "Your content can be deleted without notice."),
-    "Contract by using": ("LOW", "You agree just by visiting or using the site."),
-    "Choice of law": ("MEDIUM", "Foreign law applies instead of your local protections."),
-    "Jurisdiction": ("MEDIUM", "Disputes handled in their preferred court, not yours."),
-    "Arbitration": ("HIGH", "You waive your right to sue in court."),
+    import torch
+    from transformers import AutoTokenizer, AutoModelForSequenceClassification
+    from peft import PeftModel
+    _HAS_TORCH = True
+except Exception:
+    _HAS_TORCH = False
+
+# ── Import submodules ───────────────────────────────────────────────
+from compare import compare_contracts, render_comparison_html
+from obligations import extract_obligations, render_obligations_html
+from compliance import check_compliance, render_compliance_html
+
+# ═══════════════════════════════════════════════════════════════════════
+# 1. CONFIGURATION
+# ═══════════════════════════════════════════════════════════════════════
+
+CUAD_LABELS = [
+    "Document Name", "Parties", "Agreement Date", "Effective Date",
+    "Expiration Date", "Renewal Term", "Governing Law", "Most Favored Nation",
+    "Non-Compete", "Exclusivity", "No-Solicit of Customers",
+    "No-Solicit of Employees", "Non-Disparagement",
+    "Termination for Convenience", "ROFR/ROFO/ROFN", "Change of Control",
+    "Anti-Assignment", "Revenue/Profit Sharing", "Price Restriction",
+    "Minimum Commitment", "Volume Restriction", "IP Ownership Assignment",
+    "Joint IP Ownership", "License Grant", "Non-Transferable License",
+    "Affiliate License-Licensor", "Affiliate License-Licensee",
+    "Unlimited/All-You-Can-Eat License", "Irrevocable or Perpetual License",
+    "Source Code Escrow", "Post-Termination Services", "Audit Rights",
+    "Uncapped Liability", "Cap on Liability", "Liquidated Damages",
+    "Warranty Duration", "Insurance", "Covenant Not to Sue",
+    "Third Party Beneficiary", "Other"
+]
+
+_UNFAIR_LABELS = [
+    "Limitation of liability", "Unilateral termination", "Unilateral change",
+    "Content removal", "Contract by using", "Choice of law",
+    "Jurisdiction", "Arbitration"
+]
+
+_ALL_LABELS = CUAD_LABELS + _UNFAIR_LABELS
+
+RISK_MAP = {
+    # Critical
+    "Uncapped Liability": "CRITICAL",
+    "Arbitration": "CRITICAL",
+    "IP Ownership Assignment": "CRITICAL",
+    "Termination for Convenience": "CRITICAL",
+    "Limitation of liability": "CRITICAL",
+    "Unilateral termination": "CRITICAL",
+    "Liquidated Damages": "CRITICAL",
+    # High
+    "Non-Compete": "HIGH",
+    "Exclusivity": "HIGH",
+    "Change of Control": "HIGH",
+    "No-Solicit of Customers": "HIGH",
+    "No-Solicit of Employees": "HIGH",
+    "Unilateral change": "HIGH",
+    "Content removal": "HIGH",
+    "Anti-Assignment": "HIGH",
+    # Medium
+    "Governing Law": "MEDIUM",
+    "Jurisdiction": "MEDIUM",
+    "Choice of law": "MEDIUM",
+    "Price Restriction": "MEDIUM",
+    "Minimum Commitment": "MEDIUM",
+    "Volume Restriction": "MEDIUM",
+    "Non-Disparagement": "MEDIUM",
+    "Most Favored Nation": "MEDIUM",
+    "Revenue/Profit Sharing": "MEDIUM",
+    "Warranty Duration": "MEDIUM",
+    # Low
+    "Document Name": "LOW",
+    "Parties": "LOW",
+    "Agreement Date": "LOW",
+    "Effective Date": "LOW",
+    "Expiration Date": "LOW",
+    "Renewal Term": "LOW",
+    "Joint IP Ownership": "LOW",
+    "License Grant": "LOW",
+    "Non-Transferable License": "LOW",
+    "Affiliate License-Licensor": "LOW",
+    "Affiliate License-Licensee": "LOW",
+    "Unlimited/All-You-Can-Eat License": "LOW",
+    "Irrevocable or Perpetual License": "LOW",
+    "Source Code Escrow": "LOW",
+    "Post-Termination Services": "LOW",
+    "Audit Rights": "LOW",
+    "Cap on Liability": "LOW",
+    "Insurance": "LOW",
+    "Covenant Not to Sue": "LOW",
+    "Third Party Beneficiary": "LOW",
+    "Other": "LOW",
+    "ROFR/ROFO/ROFN": "LOW",
+    "Contract by using": "LOW",
 }
 
-# ─── Regex fallback ───
-PATTERNS = {
+DESC_MAP = {label: label.replace("_", " ") for label in _ALL_LABELS}
+DESC_MAP.update({
+    "Limitation of liability": "Company limits or excludes liability for losses, data breaches, or service failures.",
+    "Unilateral termination": "Company can terminate your account at any time without reason.",
+    "Unilateral change": "Company can change terms at any time without your consent.",
+    "Content removal": "Company can delete your content without notice or justification.",
+    "Contract by using": "You are bound to the contract simply by using the service.",
+    "Choice of law": "Governing law may differ from your country, reducing your legal protections.",
+    "Jurisdiction": "Disputes must be resolved in a jurisdiction that may disadvantage you.",
+    "Arbitration": "Forces disputes to arbitration instead of court. You waive your right to sue.",
+    "Uncapped Liability": "No financial limit on damages the party may be liable for.",
+    "Cap on Liability": "Maximum financial liability is explicitly capped.",
+    "Non-Compete": "Restrictions on competing with the counter-party.",
+    "Exclusivity": "Obligation to deal exclusively with one party.",
+    "IP Ownership Assignment": "Intellectual property rights are transferred entirely.",
+    "Termination for Convenience": "Either party may terminate without cause or notice.",
+    "Governing Law": "Specifies which jurisdiction's laws apply.",
+    "Non-Disparagement": "Agreement not to speak negatively about the other party.",
+    "ROFR/ROFO/ROFN": "Right of First Refusal / Offer / Negotiation clause.",
+    "Change of Control": "Provisions triggered by ownership or control changes.",
+    "Anti-Assignment": "Restrictions on transferring contract rights to third parties.",
+    "Liquidated Damages": "Pre-determined damages amount for breach of contract.",
+    "Source Code Escrow": "Third-party holds source code for release under defined conditions.",
+    "Post-Termination Services": "Services to be provided after the contract ends.",
+    "Audit Rights": "Right to inspect records or verify compliance.",
+    "Warranty Duration": "Length of time warranties remain in effect.",
+    "Covenant Not to Sue": "Agreement not to bring legal action against a party.",
+    "Third Party Beneficiary": "Non-party who benefits from the contract terms.",
+    "Insurance": "Insurance coverage requirements.",
+    "Revenue/Profit Sharing": "Revenue or profit sharing arrangements between parties.",
+    "Price Restriction": "Restrictions on pricing or discounting.",
+    "Minimum Commitment": "Minimum purchase or usage commitment.",
+    "Volume Restriction": "Limits on volume of goods or services.",
+    "License Grant": "Permission to use intellectual property.",
+    "Non-Transferable License": "License that cannot be transferred to third parties.",
+    "Irrevocable or Perpetual License": "License that cannot be revoked or lasts indefinitely.",
+    "Unlimited/All-You-Can-Eat License": "License with no usage limits.",
+})
+
+RISK_WEIGHTS = {"CRITICAL": 40, "HIGH": 20, "MEDIUM": 10, "LOW": 3}
+
+RISK_STYLES = {
+    "CRITICAL": ("#dc2626", "#fef2f2", "⚠️"),
+    "HIGH":     ("#ea580c", "#fff7ed", "⚡"),
+    "MEDIUM":   ("#ca8a04", "#fefce8", "📋"),
+    "LOW":      ("#16a34a", "#f0fdf4", "✓"),
+}
+
+# ═══════════════════════════════════════════════════════════════════════
+# 2. MODEL LOADING
+# ═══════════════════════════════════════════════════════════════════════
+
+cuad_tokenizer = None
+cuad_model = None
+
+def _load_cuad_model():
+    global cuad_tokenizer, cuad_model
+    if not _HAS_TORCH:
+        print("[ClauseGuard] PyTorch not available — using regex fallback")
+        return
+    try:
+        base = "nlpaueb/legal-bert-base-uncased"
+        adapter = "Mokshith31/legalbert-contract-clause-classification"
+        print(f"[ClauseGuard] Loading CUAD classifier: {adapter}")
+        cuad_tokenizer = AutoTokenizer.from_pretrained(base)
+        base_model = AutoModelForSequenceClassification.from_pretrained(
+            base, num_labels=41, ignore_mismatched_sizes=True
+        )
+        cuad_model = PeftModel.from_pretrained(base_model, adapter)
+        cuad_model.eval()
+        print("[ClauseGuard] CUAD model loaded successfully")
+    except Exception as e:
+        print(f"[ClauseGuard] CUAD model load failed: {e}")
+        cuad_tokenizer = None
+        cuad_model = None
+
+_load_cuad_model()
+
+# ═══════════════════════════════════════════════════════════════════════
+# 3. DOCUMENT PARSING
+# ═══════════════════════════════════════════════════════════════════════
+
+def parse_pdf(file_path):
+    if not _HAS_PDF:
+        return None, "PDF parsing not available (pdfplumber not installed)"
+    try:
+        text = ""
+        with pdfplumber.open(file_path) as pdf:
+            for page in pdf.pages:
+                page_text = page.extract_text()
+                if page_text:
+                    text += page_text + "\n\n"
+        return text.strip(), None
+    except Exception as e:
+        return None, f"PDF parse error: {e}"
+
+def parse_docx(file_path):
+    if not _HAS_DOCX:
+        return None, "DOCX parsing not available (python-docx not installed)"
+    try:
+        doc = DocxDocument(file_path)
+        paragraphs = [p.text for p in doc.paragraphs if p.text.strip()]
+        return "\n\n".join(paragraphs), None
+    except Exception as e:
+        return None, f"DOCX parse error: {e}"
+
+def parse_document(file_path):
+    if file_path is None:
+        return None, "No file uploaded"
+    ext = os.path.splitext(file_path)[1].lower()
+    if ext == ".pdf":
+        return parse_pdf(file_path)
+    elif ext in (".docx", ".doc"):
+        return parse_docx(file_path)
+    elif ext in (".txt", ".md", ".rst"):
+        try:
+            with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+                return f.read(), None
+        except Exception as e:
+            return None, f"Text read error: {e}"
+    else:
+        return None, f"Unsupported file type: {ext}"
+
+# ═══════════════════════════════════════════════════════════════════════
+# 4. CLAUSE DETECTION
+# ═══════════════════════════════════════════════════════════════════════
+
+def split_clauses(text):
+    text = re.sub(r'\n{3,}', '\n\n', text.strip())
+    parts = re.split(
+        r'(?<=[.!?])\s+(?=[A-Z0-9(])|(?:\n\n)(?=\d+[.)]\s|\([a-z]\)\s|[A-Z][A-Z\s]{2,})',
+        text
+    )
+    clauses = []
+    for p in parts:
+        p = p.strip()
+        if len(p) > 30:
+            clauses.append(p)
+    return clauses
+
+def classify_cuad(clause_text):
+    if cuad_model is None or cuad_tokenizer is None:
+        return _classify_regex(clause_text)
+    try:
+        inputs = cuad_tokenizer(
+            clause_text,
+            return_tensors="pt",
+            truncation=True,
+            max_length=256,
+            padding=True
+        )
+        with torch.no_grad():
+            logits = cuad_model(**inputs).logits
+        probs = torch.softmax(logits, dim=-1)[0]
+        threshold = 0.15
+        results = []
+        for i, prob in enumerate(probs):
+            if prob > threshold and i < len(CUAD_LABELS):
+                label = CUAD_LABELS[i]
+                risk = RISK_MAP.get(label, "LOW")
+                results.append({
+                    "label": label,
+                    "confidence": round(float(prob), 3),
+                    "risk": risk,
+                    "description": DESC_MAP.get(label, label),
+                })
+        results.sort(key=lambda x: x["confidence"], reverse=True)
+        if not results:
+            top_idx = int(probs.argmax())
+            label = CUAD_LABELS[top_idx] if top_idx < len(CUAD_LABELS) else "Other"
+            results.append({
+                "label": label,
+                "confidence": round(float(probs[top_idx]), 3),
+                "risk": RISK_MAP.get(label, "LOW"),
+                "description": DESC_MAP.get(label, label),
+            })
+        return results
+    except Exception as e:
+        print(f"[ClauseGuard] CUAD inference error: {e}")
+        return _classify_regex(clause_text)
+
+_REGEX_PATTERNS = {
     "Limitation of liability": [r"not liable", r"shall not be (liable|responsible)", r"in no event.*liable", r"limitation of liability", r"without warranty", r"disclaim"],
     "Unilateral termination": [r"terminat.*at any time", r"suspend.*account.*without", r"we may (terminat|suspend|discontinu)", r"right to (terminat|suspend)"],
     "Unilateral change": [r"sole discretion", r"reserves? the right to (modify|change|update|amend)", r"at any time.*without (prior )?notice", r"we may (modify|change|update)"],
@@ -40,115 +330,454 @@ PATTERNS = {
     "Choice of law": [r"governed by.*laws? of", r"shall be governed", r"laws of the state of"],
     "Jurisdiction": [r"exclusive jurisdiction", r"courts? of.*(california|delaware|new york|ireland|england)", r"submit to.*jurisdiction"],
     "Arbitration": [r"arbitrat", r"binding arbitration", r"waive.*right.*court", r"class action waiver"],
+    "Governing Law": [r"governed by", r"laws of", r"jurisdiction of"],
+    "Termination for Convenience": [r"terminat.*for convenience", r"terminat.*without cause", r"terminat.*at any time"],
+    "Non-Compete": [r"non-compete", r"shall not compete", r"competition"],
+    "Exclusivity": [r"exclusive", r"exclusivity"],
+    "IP Ownership Assignment": [r"assign.*intellectual property", r"ownership of.*ip", r"all rights.*assign"],
+    "Uncapped Liability": [r"unlimited liability", r"uncapped", r"no.*limit.*liability"],
+    "Cap on Liability": [r"cap on liability", r"maximum liability", r"liability.*shall not exceed"],
+    "Indemnification": [r"indemnif", r"hold harmless", r"defend"],
+    "Confidentiality": [r"confidential", r"non-disclosure", r"nda"],
+    "Force Majeure": [r"force majeure", r"act of god", r"beyond.*control"],
+    "Penalties": [r"penalt", r"late fee", r"default charge", r"interest on overdue"],
 }
 
-def classify_ml(text):
-    """Classify using the trained Legal-BERT model."""
-    if not ml_pipeline:
-        return classify_regex(text)
-    try:
-        preds = ml_pipeline(text, truncation=True, max_length=512)
-        results = []
-        for p in preds[0] if isinstance(preds[0], list) else preds:
-            if p["score"] > 0.5 and p["label"] in LABELS:
-                sev, desc = LABELS[p["label"]]
-                results.append({"name": p["label"], "severity": sev, "desc": desc, "confidence": round(p["score"], 2)})
-        return results
-    except Exception:
-        return classify_regex(text)
-
-def classify_regex(text):
-    """Fallback regex classifier."""
-    results = []
+def _classify_regex(text):
     text_lower = text.lower()
-    for name, pats in PATTERNS.items():
-        for p in pats:
-            if re.search(p, text_lower):
-                sev, desc = LABELS[name]
-                results.append({"name": name, "severity": sev, "desc": desc, "confidence": 0.7})
+    results = []
+    seen = set()
+    for label, patterns in _REGEX_PATTERNS.items():
+        for pat in patterns:
+            if re.search(pat, text_lower):
+                if label not in seen:
+                    risk = RISK_MAP.get(label, "MEDIUM")
+                    results.append({
+                        "label": label,
+                        "confidence": 0.7,
+                        "risk": risk,
+                        "description": DESC_MAP.get(label, label),
+                    })
+                    seen.add(label)
                 break
     return results
 
-def split_clauses(text):
-    text = re.sub(r'\n{2,}', '\n', text.strip())
-    parts = re.split(r'(?<=[.!?])\s+(?=[A-Z0-9(])|(?:\n)(?=\d+[.)]\s|\([a-z]\)\s)', text)
-    return [c.strip() for c in parts if len(c.strip()) > 30]
+# ═══════════════════════════════════════════════════════════════════════
+# 5. LEGAL NER
+# ═══════════════════════════════════════════════════════════════════════
+
+def extract_entities(text):
+    entities = []
+    date_patterns = [
+        (r'\b(?:January|February|March|April|May|June|July|August|September|October|November|December)\s+\d{1,2},?\s+\d{4}\b', "DATE"),
+        (r'\b\d{1,2}/\d{1,2}/\d{2,4}\b', "DATE"),
+        (r'\b\d{1,2}-\d{1,2}-\d{2,4}\b', "DATE"),
+        (r'\b(?:Effective|Commencement|Expiration|Termination)\s+Date\b', "DATE_REF"),
+    ]
+    for pat, etype in date_patterns:
+        for m in re.finditer(pat, text, re.IGNORECASE):
+            entities.append({"text": m.group(), "type": etype, "start": m.start(), "end": m.end()})
+    money_patterns = [
+        (r'\$\d{1,3}(?:,\d{3})*(?:\.\d{2})?(?:\s*(?:million|billion|thousand|M|B|K))?', "MONEY"),
+        (r'\b\d{1,3}(?:,\d{3})*(?:\.\d{2})?\s*(?:USD|EUR|GBP|dollars|euros)', "MONEY"),
+    ]
+    for pat, etype in money_patterns:
+        for m in re.finditer(pat, text, re.IGNORECASE):
+            entities.append({"text": m.group(), "type": etype, "start": m.start(), "end": m.end()})
+    party_patterns = [
+        (r'\b[A-Z][A-Za-z0-9\s&]+(?:Inc\.|LLC|Ltd\.|Limited|Corp\.|Corporation|PLC|GmbH|AG|S\.A\.|B\.V\.)\b', "PARTY"),
+        (r'\b(?:Party A|Party B|Disclosing Party|Receiving Party|Licensor|Licensee|Buyer|Seller|Tenant|Landlord|Employer|Employee|Company|Customer|Vendor|Client)\b', "PARTY_ROLE"),
+    ]
+    for pat, etype in party_patterns:
+        for m in re.finditer(pat, text):
+            entities.append({"text": m.group(), "type": etype, "start": m.start(), "end": m.end()})
+    jurisdiction_patterns = [
+        (r'\b(?:State|Laws?) of [A-Z][a-zA-Z\s]+', "JURISDICTION"),
+        (r'\b(?:California|Delaware|New York|Texas|Florida|England|Ireland|Germany|France|Singapore|Hong Kong)\b', "JURISDICTION"),
+    ]
+    for pat, etype in jurisdiction_patterns:
+        for m in re.finditer(pat, text, re.IGNORECASE):
+            entities.append({"text": m.group(), "type": etype, "start": m.start(), "end": m.end()})
+    defined_patterns = [
+        (r'"([A-Z][A-Z\s]+)"', "DEFINED_TERM"),
+        (r'\(([A-Z][A-Z\s]+)\)', "DEFINED_TERM"),
+    ]
+    for pat, etype in defined_patterns:
+        for m in re.finditer(pat, text):
+            entities.append({"text": m.group(1), "type": etype, "start": m.start(), "end": m.end()})
+    entities.sort(key=lambda x: (x["start"], -(x["end"] - x["start"])))
+    filtered = []
+    last_end = -1
+    for e in entities:
+        if e["start"] >= last_end:
+            filtered.append(e)
+            last_end = e["end"]
+    return filtered
+
+# ═══════════════════════════════════════════════════════════════════════
+# 6. NLI / CONTRADICTION DETECTION
+# ═══════════════════════════════════════════════════════════════════════
+
+_CONTRADICTION_PAIRS = [
+    (["Uncapped Liability", "unlimited liability"], ["Cap on Liability", "cap on liability"],
+     "Liability cannot be both uncapped and capped simultaneously."),
+    (["Governing Law"], ["Governing Law"],
+     "Multiple governing law provisions detected — verify consistency."),
+    (["Termination for Convenience", "terminat.*convenience"], ["Fixed Term", "fixed term"],
+     "Contract has both fixed term and termination for convenience — review carefully."),
+    (["IP Ownership Assignment", "assign.*ip"], ["Joint IP Ownership", "joint ownership"],
+     "IP cannot be both fully assigned and jointly owned."),
+]
+
+def detect_contradictions(clause_results):
+    contradictions = []
+    labels_found = set()
+    for cr in clause_results:
+        labels_found.add(cr["label"])
+    for group_a, group_b, explanation in _CONTRADICTION_PAIRS:
+        found_a = any(l in labels_found for l in group_a)
+        found_b = any(l in labels_found for l in group_b)
+        if found_a and found_b:
+            contradictions.append({
+                "type": "CONTRADICTION",
+                "explanation": explanation,
+                "severity": "HIGH",
+                "clauses": list(set(group_a + group_b)),
+            })
+    critical_clauses = ["Governing Law", "Termination for Convenience", "Limitation of liability", "Arbitration"]
+    for cc in critical_clauses:
+        if cc not in labels_found:
+            contradictions.append({
+                "type": "MISSING",
+                "explanation": f"Critical clause '{cc}' not detected in the document.",
+                "severity": "MEDIUM",
+                "clauses": [cc],
+            })
+    return contradictions
+
+# ═══════════════════════════════════════════════════════════════════════
+# 7. RISK SCORING
+# ═══════════════════════════════════════════════════════════════════════
+
+def compute_risk_score(clause_results, total_clauses):
+    sev_counts = {"CRITICAL": 0, "HIGH": 0, "MEDIUM": 0, "LOW": 0}
+    for cr in clause_results:
+        sev = cr.get("risk", "LOW")
+        sev_counts[sev] += 1
+    if total_clauses == 0:
+        return 0, "A", sev_counts
+    weighted = sum(sev_counts[s] * RISK_WEIGHTS[s] for s in sev_counts)
+    risk = min(100, round(weighted / max(1, total_clauses) * 10))
+    if risk >= 70: grade = "F"
+    elif risk >= 50: grade = "D"
+    elif risk >= 30: grade = "C"
+    elif risk >= 15: grade = "B"
+    else: grade = "A"
+    return risk, grade, sev_counts
 
-def analyze(text):
-    if not text or len(text.strip()) < 50:
-        return "", ""
+# ═══════════════════════════════════════════════════════════════════════
+# 8. MAIN ANALYSIS PIPELINE
+# ═══════════════════════════════════════════════════════════════════════
 
+def analyze_contract(text):
+    if not text or len(text.strip()) < 50:
+        return None, "Document too short (minimum 50 characters)"
     clauses = split_clauses(text)
     if not clauses:
-        return "", ""
-
-    flagged = []
-    sev_counts = {"HIGH": 0, "MEDIUM": 0, "LOW": 0}
-
+        return None, "No clauses detected in document"
+    clause_results = []
     for clause in clauses:
-        hits = classify_ml(clause)
-        if hits:
-            flagged.append({"text": clause, "hits": hits})
-            for h in hits:
-                sev_counts[h["severity"]] += 1
-
-    total = len(clauses)
-    risk = min(100, round((sev_counts["HIGH"] * 20 + sev_counts["MEDIUM"] * 10 + sev_counts["LOW"] * 5) / max(1, total) * 100))
-
-    if risk >= 60: grade = "F"
-    elif risk >= 40: grade = "D"
-    elif risk >= 20: grade = "C"
-    elif risk >= 10: grade = "B"
-    else: grade = "A"
-
-    engine = "Legal-BERT" if ml_pipeline else "Pattern matching"
-
-    # Build HTML
-    summary = f"""<div style="font-family:system-ui,sans-serif;">
-  <div style="border:1px solid #e4e4e7;border-radius:8px;padding:20px;margin-bottom:16px;">
-    <div style="display:flex;justify-content:space-between;align-items:baseline;">
-      <div>
-        <span style="font-size:32px;font-weight:600;">{risk}</span>
-        <span style="font-size:13px;color:#a1a1aa;">/100 risk</span>
+        predictions = classify_cuad(clause)
+        if predictions:
+            for pred in predictions:
+                clause_results.append({
+                    "text": clause,
+                    "label": pred["label"],
+                    "confidence": pred["confidence"],
+                    "risk": pred["risk"],
+                    "description": pred["description"],
+                })
+    entities = extract_entities(text)
+    contradictions = detect_contradictions(clause_results)
+    risk, grade, sev_counts = compute_risk_score(clause_results, len(clauses))
+    obligations = extract_obligations(text)
+    compliance = check_compliance(text)
+    result = {
+        "metadata": {
+            "analysis_date": datetime.now().isoformat(),
+            "total_clauses": len(clauses),
+            "flagged_clauses": len(set(cr["text"] for cr in clause_results)),
+            "model": "Legal-BERT + CUAD (41 classes)" if cuad_model else "Regex fallback",
+        },
+        "risk": {
+            "score": risk,
+            "grade": grade,
+            "breakdown": sev_counts,
+        },
+        "clauses": clause_results,
+        "entities": entities,
+        "contradictions": contradictions,
+        "obligations": obligations,
+        "compliance": compliance,
+        "raw_text": text,
+    }
+    return result, None
+
+# ═══════════════════════════════════════════════════════════════════════
+# 9. EXPORT FUNCTIONS
+# ═══════════════════════════════════════════════════════════════════════
+
+def export_json(result):
+    if result is None:
+        return None
+    return json.dumps(result, indent=2, default=str)
+
+def export_csv(result):
+    if result is None:
+        return None
+    output = io.StringIO()
+    writer = csv.writer(output)
+    writer.writerow(["Clause Text", "Label", "Risk", "Confidence", "Description"])
+    for cr in result.get("clauses", []):
+        writer.writerow([
+            cr.get("text", "")[:500],
+            cr.get("label", ""),
+            cr.get("risk", ""),
+            cr.get("confidence", ""),
+            cr.get("description", ""),
+        ])
+    return output.getvalue()
+
+# ═══════════════════════════════════════════════════════════════════════
+# 10. UI RENDERING
+# ═══════════════════════════════════════════════════════════════════════
+
+def render_summary(result):
+    if result is None:
+        return ""
+    risk = result["risk"]
+    score = risk["score"]
+    grade = risk["grade"]
+    breakdown = risk["breakdown"]
+    grade_color = {
+        "A": "#16a34a", "B": "#65a30d", "C": "#ca8a04",
+        "D": "#ea580c", "F": "#dc2626",
+    }.get(grade, "#6b7280")
+    crit, high, med, low = breakdown["CRITICAL"], breakdown["HIGH"], breakdown["MEDIUM"], breakdown["LOW"]
+    html = f"""
+    <div style="font-family:system-ui,sans-serif;padding:16px;border:1px solid #e5e7eb;border-radius:12px;background:#fff;">
+      <div style="text-align:center;margin-bottom:16px;">
+        <div style="font-size:48px;font-weight:700;color:{grade_color};">{score}</div>
+        <div style="font-size:14px;color:#6b7280;">/100 Risk Score</div>
+        <div style="display:inline-block;margin-top:8px;padding:4px 16px;border-radius:20px;background:{grade_color};color:white;font-weight:600;font-size:14px;">
+          Grade {grade}
+        </div>
+      </div>
+      <div style="display:grid;grid-template-columns:1fr 1fr;gap:8px;margin-bottom:12px;">
+        <div style="padding:8px;border-radius:6px;background:#fef2f2;text-align:center;">
+          <div style="font-size:20px;font-weight:700;color:#dc2626;">{crit}</div>
+          <div style="font-size:11px;color:#991b1b;">Critical</div>
+        </div>
+        <div style="padding:8px;border-radius:6px;background:#fff7ed;text-align:center;">
+          <div style="font-size:20px;font-weight:700;color:#ea580c;">{high}</div>
+          <div style="font-size:11px;color:#9a3412;">High</div>
+        </div>
+        <div style="padding:8px;border-radius:6px;background:#fefce8;text-align:center;">
+          <div style="font-size:20px;font-weight:700;color:#ca8a04;">{med}</div>
+          <div style="font-size:11px;color:#854d0e;">Medium</div>
+        </div>
+        <div style="padding:8px;border-radius:6px;background:#f0fdf4;text-align:center;">
+          <div style="font-size:20px;font-weight:700;color:#16a34a;">{low}</div>
+          <div style="font-size:11px;color:#166534;">Low</div>
+        </div>
+      </div>
+      <div style="font-size:12px;color:#6b7280;text-align:center;">
+        {result['metadata']['total_clauses']} clauses analyzed · {result['metadata']['flagged_clauses']} flagged
+        <br>Engine: {result['metadata']['model']}
       </div>
-      <span style="font-size:13px;font-weight:500;padding:2px 10px;border-radius:4px;{
-        'background:#fef2f2;color:#b91c1c;' if grade in ('F','D') else
-        'background:#fffbeb;color:#a16207;' if grade == 'C' else
-        'background:#f0fdf4;color:#15803d;'
-      }">Grade {grade}</span>
     </div>
-    <p style="margin-top:8px;font-size:12px;color:#a1a1aa;">{total} clauses · {len(flagged)} flagged · {sev_counts['HIGH']} high · {sev_counts['MEDIUM']} medium · {sev_counts['LOW']} low · Engine: {engine}</p>
-  </div>"""
-
-    if not flagged:
-        summary += '<div style="border:1px solid #e4e4e7;border-radius:8px;padding:24px;text-align:center;"><p style="font-size:14px;color:#71717a;">No unfair clauses found.</p></div>'
-    else:
-        for item in flagged:
-            max_sev = max(item["hits"], key=lambda h: {"HIGH":3,"MEDIUM":2,"LOW":1}[h["severity"]])["severity"]
-            border = {"HIGH":"#fca5a5","MEDIUM":"#fcd34d","LOW":"#93c5fd"}[max_sev]
-
-            tags = ""
-            for h in item["hits"]:
-                ts = {"HIGH":"background:#fef2f2;color:#b91c1c;border:1px solid #fecaca;",
-                      "MEDIUM":"background:#fffbeb;color:#a16207;border:1px solid #fde68a;",
-                      "LOW":"background:#eff6ff;color:#1d4ed8;border:1px solid #bfdbfe;"}[h["severity"]]
-                conf = f' ({h["confidence"]})' if h.get("confidence") and ml_pipeline else ""
-                tags += f'<span style="{ts}font-size:11px;font-weight:500;padding:1px 8px;border-radius:3px;margin-right:4px;">{h["name"]}{conf}</span>'
+    """
+    return html
 
-            descs = "".join(f'<p style="font-size:12px;color:#71717a;margin-top:4px;">{h["desc"]}</p>' for h in item["hits"])
-            preview = item["text"][:200] + ("..." if len(item["text"]) > 200 else "")
-
-            summary += f'''<div style="border:1px solid #e4e4e7;border-left:3px solid {border};border-radius:8px;padding:14px;margin-bottom:8px;">
-    <p style="font-size:13px;color:#3f3f46;line-height:1.6;">{preview}</p>
-    <div style="margin-top:8px;">{tags}</div>
-    {descs}
-  </div>'''
-
-    summary += "</div>"
-    return summary, ""
-
-
-SPOTIFY = """By using the Spotify Service, you agree to be bound by these Terms of Use.
+def render_clause_cards(result):
+    if result is None:
+        return ""
+    clauses = result.get("clauses", [])
+    if not clauses:
+        return '<div style="padding:24px;text-align:center;color:#6b7280;">No clauses detected.</div>'
+    grouped = defaultdict(list)
+    for cr in clauses:
+        grouped[cr["text"]].append(cr)
+    html = '<div style="font-family:system-ui,sans-serif;">'
+    for text, items in grouped.items():
+        max_risk = max(items, key=lambda x: {"CRITICAL":4,"HIGH":3,"MEDIUM":2,"LOW":1}[x["risk"]])["risk"]
+        border, bg, icon = RISK_STYLES[max_risk]
+        tags = ""
+        for item in items:
+            tag_bg = RISK_STYLES[item["risk"]][1]
+            tag_color = RISK_STYLES[item["risk"]][0]
+            tags += f'<span style="background:{tag_bg};color:{tag_color};border:1px solid {tag_color}33;padding:2px 8px;border-radius:12px;font-size:11px;font-weight:500;margin-right:4px;">{item["label"]} ({item["confidence"]})</span>'
+        descs = "".join(
+            f'<p style="font-size:12px;color:#6b7280;margin:4px 0 0 0;">{item["description"]}</p>'
+            for item in items
+        )
+        preview = text[:300] + ("..." if len(text) > 300 else "")
+        preview = preview.replace("<", "&lt;").replace(">", "&gt;")
+        html += f"""
+        <div style="border:1px solid #e5e7eb;border-left:4px solid {border};border-radius:8px;padding:14px;margin-bottom:10px;background:#fafafa;">
+          <div style="display:flex;align-items:center;gap:6px;margin-bottom:6px;">
+            <span style="font-size:16px;">{icon}</span>
+            <span style="font-size:12px;font-weight:600;color:{border};text-transform:uppercase;">{max_risk}</span>
+          </div>
+          <p style="font-size:13px;color:#374151;line-height:1.6;margin:0 0 8px 0;">{preview}</p>
+          <div style="margin-bottom:6px;">{tags}</div>
+          {descs}
+        </div>
+        """
+    html += "</div>"
+    return html
+
+def render_entities(result):
+    if result is None:
+        return ""
+    entities = result.get("entities", [])
+    if not entities:
+        return '<div style="padding:16px;color:#6b7280;">No entities detected.</div>'
+    grouped = defaultdict(list)
+    for e in entities:
+        grouped[e["type"]].append(e["text"])
+    html = '<div style="font-family:system-ui,sans-serif;">'
+    for etype, texts in grouped.items():
+        unique = list(dict.fromkeys(texts))[:20]
+        color = {
+            "DATE": "#3b82f6", "DATE_REF": "#60a5fa",
+            "MONEY": "#22c55e",
+            "PARTY": "#8b5cf6", "PARTY_ROLE": "#a78bfa",
+            "JURISDICTION": "#f59e0b",
+            "DEFINED_TERM": "#ec4899",
+        }.get(etype, "#6b7280")
+        items_html = "".join(
+            f'<span style="display:inline-block;background:{color}15;color:{color};border:1px solid {color}40;padding:3px 10px;border-radius:6px;font-size:12px;margin:3px;">{t}</span>'
+            for t in unique
+        )
+        html += f"""
+        <div style="margin-bottom:12px;">
+          <div style="font-size:12px;font-weight:600;color:#374151;margin-bottom:6px;text-transform:uppercase;">{etype}</div>
+          <div>{items_html}</div>
+        </div>
+        """
+    html += "</div>"
+    return html
+
+def render_contradictions(result):
+    if result is None:
+        return ""
+    contradictions = result.get("contradictions", [])
+    if not contradictions:
+        return '<div style="padding:16px;color:#16a34a;">✓ No contradictions or missing clauses detected.</div>'
+    html = '<div style="font-family:system-ui,sans-serif;">'
+    for c in contradictions:
+        sev_color = RISK_STYLES[c["severity"]][0]
+        icon = "⚠️" if c["type"] == "CONTRADICTION" else "📋"
+        html += f"""
+        <div style="border:1px solid #e5e7eb;border-left:4px solid {sev_color};border-radius:8px;padding:12px;margin-bottom:8px;background:#fafafa;">
+          <div style="display:flex;align-items:center;gap:6px;margin-bottom:4px;">
+            <span>{icon}</span>
+            <span style="font-size:12px;font-weight:600;color:{sev_color};">{c["type"]}</span>
+          </div>
+          <p style="font-size:13px;color:#374151;margin:0;">{c["explanation"]}</p>
+        </div>
+        """
+    html += "</div>"
+    return html
+
+def render_document_viewer(result):
+    if result is None:
+        return ""
+    text = result.get("raw_text", "")
+    entities = sorted(result.get("entities", []), key=lambda x: x["start"])
+    html_parts = []
+    last_end = 0
+    for e in entities:
+        if e["start"] >= last_end:
+            html_parts.append(text[last_end:e["start"]].replace("<", "&lt;").replace(">", "&gt;"))
+            color = {
+                "DATE": "#bfdbfe", "DATE_REF": "#bfdbfe",
+                "MONEY": "#bbf7d0",
+                "PARTY": "#ddd6fe", "PARTY_ROLE": "#ddd6fe",
+                "JURISDICTION": "#fde68a",
+                "DEFINED_TERM": "#fbcfe8",
+            }.get(e["type"], "#e5e7eb")
+            label = e["type"].replace("_", " ")
+            html_parts.append(
+                f'<mark style="background:{color};padding:1px 2px;border-radius:2px;font-size:12px;" title="{label}">{e["text"].replace("<","&lt;").replace(">","&gt;")}</mark>'
+            )
+            last_end = e["end"]
+    html_parts.append(text[last_end:].replace("<", "&lt;").replace(">", "&gt;"))
+    highlighted = "".join(html_parts)
+    return f"""
+    <div style="font-family:monospace;font-size:13px;line-height:1.6;padding:16px;border:1px solid #e5e7eb;border-radius:8px;background:#fff;max-height:600px;overflow-y:auto;white-space:pre-wrap;">
+      {highlighted}
+    </div>
+    """
+
+# ═══════════════════════════════════════════════════════════════════════
+# 11. COMPARISON UI FUNCTIONS
+# ═══════════════════════════════════════════════════════════════════════
+
+def run_comparison(text_a, text_b):
+    if not text_a or len(text_a.strip()) < 50:
+        return "Contract A is too short", ""
+    if not text_b or len(text_b.strip()) < 50:
+        return "Contract B is too short", ""
+    result = compare_contracts(text_a, text_b)
+    return render_comparison_html(result), json.dumps(result, indent=2)
+
+# ═══════════════════════════════════════════════════════════════════════
+# 12. GRADIO UI
+# ═══════════════════════════════════════════════════════════════════════
+
+def process_upload(file):
+    if file is None:
+        return "", "No file uploaded"
+    text, error = parse_document(file)
+    if error:
+        return "", error
+    return text, "Document loaded successfully"
+
+def run_analysis(text):
+    if not text or len(text.strip()) < 50:
+        err_html = '<p style="color:#dc2626;padding:16px;">Document too short (minimum 50 characters)</p>'
+        return [err_html] * 7 + [None, None, ""]
+    result, error = analyze_contract(text)
+    if error:
+        err_html = f'<p style="color:#dc2626;padding:16px;">{error}</p>'
+        return [err_html] * 7 + [None, None, error]
+    json_path = "/tmp/clauseguard_report.json"
+    with open(json_path, "w") as f:
+        json.dump(result, f, indent=2, default=str)
+    csv_content = export_csv(result)
+    csv_path = "/tmp/clauseguard_report.csv"
+    with open(csv_path, "w") as f:
+        f.write(csv_content)
+    return [
+        render_summary(result),
+        render_clause_cards(result),
+        render_entities(result),
+        render_contradictions(result),
+        render_document_viewer(result),
+        render_obligations_html(result.get("obligations", [])),
+        render_compliance_html(result.get("compliance", {})),
+        json_path,
+        csv_path,
+        "Analysis complete",
+    ]
+
+def do_clear():
+    return [""] * 7 + [None, None, ""]
+
+# ── Example contracts ──
+SPOTIFY_TOS = """By using the Spotify Service, you agree to be bound by these Terms of Use.
 
 Spotify may, in its sole discretion, modify or update these Terms of Service at any time without prior notice. Your continued use of the Service after any such changes constitutes your acceptance of the new Terms of Service.
 
@@ -160,39 +789,235 @@ Spotify may terminate your account or suspend your access at any time, with or w
 
 These Terms will be governed by and construed in accordance with the laws of the State of New York.
 
-Any dispute shall be finally settled by arbitration in New York County."""
+Any dispute shall be finally settled by arbitration in New York County. The parties waive any right to a jury trial."""
 
-RENTAL = """The Landlord reserves the right to enter the premises at any time without prior notice for inspection or any other purpose deemed necessary in their sole discretion.
+RENTAL_AGREEMENT = """The Landlord reserves the right to enter the premises at any time without prior notice for inspection or any other purpose deemed necessary in their sole discretion.
 
 The Landlord shall not be liable for any damage to the Tenant's personal property, whether caused by water leaks, fire, theft, or any other cause, including the Landlord's own negligence.
 
 The Landlord may terminate this lease at any time with only 7 days written notice, for any reason or no reason at all.
 
-Any disputes arising from this lease agreement shall be resolved exclusively in the courts of the Landlord's choosing, and the Tenant waives the right to a jury trial.
+Any disputes arising from this lease agreement shall be resolved exclusively in the courts of the State of California, and the Tenant waives the right to a jury trial.
 
 The Landlord reserves the right to modify the terms of this lease at any time. Continued occupancy constitutes acceptance of the new terms."""
 
-demo = gr.Blocks(title="ClauseGuard")
+NDA_SAMPLE = """NON-DISCLOSURE AGREEMENT
+
+This Non-Disclosure Agreement (the "Agreement") is entered into as of January 15, 2024 (the "Effective Date") by and between Acme Technologies, Inc. ("Disclosing Party") and Beta Solutions LLC ("Receiving Party").
+
+1. Governing Law. This Agreement shall be governed by and construed in accordance with the laws of the State of Delaware, without regard to its conflict of law principles.
+
+2. Term. This Agreement shall remain in effect for a period of three (3) years from the Effective Date.
+
+3. Termination. Either party may terminate this Agreement for convenience upon thirty (30) days prior written notice.
+
+4. Intellectual Property. All Confidential Information disclosed hereunder shall remain the exclusive property of the Disclosing Party. The Receiving Party hereby assigns to the Disclosing Party all right, title, and interest in any derivative works.
+
+5. Limitation of Liability. IN NO EVENT SHALL EITHER PARTY BE LIABLE FOR ANY INDIRECT, INCIDENTAL, SPECIAL, CONSEQUENTIAL, OR PUNITIVE DAMAGES.
+
+6. Indemnification. The Receiving Party shall indemnify and hold harmless the Disclosing Party from any and all claims arising from a breach of this Agreement.
+
+7. Non-Compete. During the term of this Agreement and for a period of two (2) years thereafter, the Receiving Party shall not engage in any business that competes with the Disclosing Party."""
+
+COMPLEX_CONTRACT = """MASTER SERVICE AGREEMENT
+
+This Master Service Agreement ("MSA") is entered into as of March 1, 2024 (the "Effective Date") by and between CloudTech Solutions, Inc., a Delaware corporation ("Provider") and Global Retail Partners LLC, a New York limited liability company ("Customer").
+
+1. SERVICES. Provider shall provide cloud hosting and data processing services as described in Exhibit A. Provider shall comply with all applicable laws including GDPR and CCPA.
+
+2. TERM AND RENEWAL. The initial term is twelve (12) months, automatically renewing for successive one (1) year periods unless terminated in accordance with Section 7.
+
+3. FEES AND PAYMENT. Customer shall pay a monthly fee of $25,000 within 30 days of invoice. Late payments incur a penalty of 1.5% per month. The total contract value is $300,000.
+
+4. LIABILITY. Provider's aggregate liability shall not exceed $1,000,000. IN NO EVENT SHALL PROVIDER BE LIABLE FOR LOST PROFITS OR CONSEQUENTIAL DAMAGES. Customer assumes all risk of data loss.
 
-with demo:
-    gr.HTML('<div style="font-family:system-ui,sans-serif;padding:16px 0;"><h1 style="font-size:20px;font-weight:600;margin:0;">ClauseGuard</h1><p style="font-size:13px;color:#a1a1aa;margin-top:2px;">Paste a Terms of Service, contract, or lease. Get a risk breakdown.</p></div>')
+5. INDEMNIFICATION. Each party shall indemnify the other for third-party claims arising from breach of this Agreement. Customer shall indemnify Provider for claims arising from Customer Data.
 
-    with gr.Row():
-        with gr.Column(scale=1):
-            text_input = gr.Textbox(label="Document text", placeholder="Paste here...", lines=14, max_lines=40)
+6. INTELLECTUAL PROPERTY. Provider retains all IP rights. Customer receives a non-transferable, non-exclusive license for the term. Upon termination, Customer shall return or destroy all Provider materials within 10 business days.
+
+7. TERMINATION. Either party may terminate for convenience with 90 days notice. Provider may terminate immediately for non-payment. Upon termination, Customer shall pay all outstanding fees.
+
+8. GOVERNING LAW. This Agreement is governed by the laws of the State of Delaware. Disputes shall be resolved by binding arbitration in Wilmington, Delaware.
+
+9. FORCE MAJEURE. Neither party shall be liable for delays due to acts of God, war, terrorism, or government action.
+
+10. AUDIT RIGHTS. Customer may audit Provider's compliance annually. Provider shall provide SOC 2 Type II reports within 30 days of request.
+
+11. INSURANCE. Provider shall maintain general liability insurance of at least $5,000,000 and cyber liability insurance of at least $2,000,000.
+
+12. CONFIDENTIALITY. Both parties agree to keep Confidential Information secure for five (5) years. This obligation survives termination.
+
+13. ASSIGNMENT. Neither party may assign this Agreement without prior written consent. Any attempted assignment is void.
+
+14. THIRD PARTY BENEFICIARY. No third party shall have rights under this Agreement except as expressly provided."""
+
+with gr.Blocks(
+    title="ClauseGuard — AI Contract Analysis",
+    css="""
+        .gradio-container { max-width: 1600px !important; }
+    """
+) as demo:
+
+    gr.HTML("""
+    <div style="display:flex;align-items:center;justify-content:space-between;padding:12px 0;border-bottom:2px solid #e5e7eb;margin-bottom:16px;">
+      <div>
+        <h1 style="font-size:24px;font-weight:700;margin:0;color:#1f2937;">🛡️ ClauseGuard</h1>
+        <p style="font-size:13px;color:#6b7280;margin:4px 0 0 0;">AI-Powered Legal Contract Analysis · 41 Clause Categories · Risk Scoring · NER · NLI · Compliance · Obligations</p>
+      </div>
+      <div style="font-size:12px;color:#9ca3af;">v2.0 · World's Best Open-Source Legal AI</div>
+    </div>
+    """)
+
+    # ── Main Tabs: Analysis vs Comparison ──
+    with gr.Tabs():
+
+        # ═══════ TAB 1: Single Contract Analysis ═══════
+        with gr.Tab("📄 Single Contract Analysis"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    file_input = gr.File(
+                        label="📁 Upload Contract (PDF/DOCX/TXT)",
+                        file_types=[".pdf", ".docx", ".doc", ".txt", ".md"],
+                    )
+                    load_btn = gr.Button("Load Document", variant="secondary", size="sm")
+                    load_status = gr.Textbox(label="Status", interactive=False, lines=1)
+
+                with gr.Column(scale=3):
+                    text_input = gr.Textbox(
+                        label="📄 Contract Text",
+                        placeholder="Paste contract text here, or upload a file above...",
+                        lines=14,
+                        max_lines=40,
+                        show_copy_button=True,
+                    )
+
+                with gr.Column(scale=1):
+                    scan_btn = gr.Button("🔍 Analyze Contract", variant="primary", size="lg")
+                    clear_btn = gr.Button("Clear", variant="secondary", size="sm")
+                    status_msg = gr.Textbox(label="Analysis Status", interactive=False, lines=1)
+
+            # ── Examples ──
             with gr.Row():
-                scan_btn = gr.Button("Scan", variant="primary")
-                clear_btn = gr.Button("Clear", variant="secondary")
-            gr.Examples(examples=[[SPOTIFY], [RENTAL]], inputs=[text_input], label="Examples")
+                gr.Examples(
+                    examples=[[SPOTIFY_TOS], [RENTAL_AGREEMENT], [NDA_SAMPLE], [COMPLEX_CONTRACT]],
+                    inputs=[text_input],
+                    label="Example Contracts",
+                )
 
-        with gr.Column(scale=1):
-            results_html = gr.HTML(label="Results")
-            hidden = gr.HTML(visible=False)
+            # ── Results ──
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("### 📊 Risk Summary")
+                    summary_html = gr.HTML()
+
+                    gr.Markdown("### 📥 Export Reports")
+                    json_file = gr.File(label="JSON Report")
+                    csv_file = gr.File(label="CSV Report")
+
+                with gr.Column(scale=3):
+                    with gr.Tabs():
+                        with gr.Tab("📄 Document"):
+                            doc_html = gr.HTML(label="Document Viewer")
+                        with gr.Tab("⚠️ Clauses (41 Categories)"):
+                            clauses_html = gr.HTML(label="Detected Clauses")
+                        with gr.Tab("🏷️ Entities"):
+                            entities_html = gr.HTML(label="Named Entities")
+                        with gr.Tab("🔍 Contradictions"):
+                            nli_html = gr.HTML(label="Contradictions & Missing Clauses")
+                        with gr.Tab("📋 Obligations"):
+                            obligations_html = gr.HTML(label="Obligation Tracker")
+                        with gr.Tab("⚖️ Compliance"):
+                            compliance_html = gr.HTML(label="Compliance Checker")
+
+        # ═══════ TAB 2: Contract Comparison ═══════
+        with gr.Tab("🔀 Compare Contracts"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    comp_file_a = gr.File(
+                        label="📁 Contract A (PDF/DOCX/TXT)",
+                        file_types=[".pdf", ".docx", ".doc", ".txt"],
+                    )
+                    comp_load_a = gr.Button("Load A", variant="secondary", size="sm")
+                    comp_status_a = gr.Textbox(label="Status A", interactive=False, lines=1)
+
+                with gr.Column(scale=3):
+                    comp_text_a = gr.Textbox(
+                        label="Contract A",
+                        placeholder="Paste contract A here...",
+                        lines=12,
+                        show_copy_button=True,
+                    )
+
+                with gr.Column(scale=1):
+                    comp_file_b = gr.File(
+                        label="📁 Contract B (PDF/DOCX/TXT)",
+                        file_types=[".pdf", ".docx", ".doc", ".txt"],
+                    )
+                    comp_load_b = gr.Button("Load B", variant="secondary", size="sm")
+                    comp_status_b = gr.Textbox(label="Status B", interactive=False, lines=1)
+
+                with gr.Column(scale=3):
+                    comp_text_b = gr.Textbox(
+                        label="Contract B",
+                        placeholder="Paste contract B here...",
+                        lines=12,
+                        show_copy_button=True,
+                    )
 
-    scan_btn.click(fn=analyze, inputs=[text_input], outputs=[results_html, hidden])
-    clear_btn.click(fn=lambda: ("", "", ""), outputs=[text_input, results_html, hidden])
+            with gr.Row():
+                with gr.Column(scale=1):
+                    comp_btn = gr.Button("🔀 Compare Contracts", variant="primary", size="lg")
+                with gr.Column(scale=5):
+                    comp_status = gr.Textbox(label="Comparison Status", interactive=False, lines=1)
 
-    gr.HTML('<p style="font-family:system-ui,sans-serif;font-size:11px;color:#a1a1aa;text-align:center;padding:16px 0;border-top:1px solid #f4f4f5;margin-top:16px;">Not legal advice. Model: Legal-BERT fine-tuned on CLAUDETTE. <a href="https://huggingface.co/gaurv007/clauseguard-legal-bert" style="color:#71717a;">Model</a> · <a href="https://huggingface.co/datasets/coastalcph/lex_glue" style="color:#71717a;">Dataset</a></p>')
+            with gr.Row():
+                with gr.Column(scale=4):
+                    comp_result_html = gr.HTML(label="Comparison Results")
+                with gr.Column(scale=2):
+                    comp_json = gr.JSON(label="Raw Comparison Data")
+
+    # ── Events ──
+    def _load_file(file):
+        text, err = parse_document(file) if file else ("", "No file")
+        if err and not text:
+            return "", err
+        return text, "Loaded successfully" if not err else err
+
+    load_btn.click(_load_file, inputs=[file_input], outputs=[text_input, load_status])
+    comp_load_a.click(_load_file, inputs=[comp_file_a], outputs=[comp_text_a, comp_status_a])
+    comp_load_b.click(_load_file, inputs=[comp_file_b], outputs=[comp_text_b, comp_status_b])
+
+    scan_btn.click(
+        run_analysis,
+        inputs=[text_input],
+        outputs=[summary_html, clauses_html, entities_html, nli_html,
+                 doc_html, obligations_html, compliance_html,
+                 json_file, csv_file, status_msg]
+    )
+
+    clear_btn.click(
+        do_clear,
+        outputs=[summary_html, clauses_html, entities_html, nli_html,
+                 doc_html, obligations_html, compliance_html,
+                 json_file, csv_file, status_msg]
+    )
+
+    comp_btn.click(
+        run_comparison,
+        inputs=[comp_text_a, comp_text_b],
+        outputs=[comp_result_html, comp_json]
+    )
+
+    gr.HTML("""
+    <div style="margin-top:24px;padding:16px 0;border-top:1px solid #e5e7eb;text-align:center;">
+      <p style="font-size:11px;color:#9ca3af;">
+        ⚠️ Not legal advice. For informational purposes only.
+        · Model: <a href="https://huggingface.co/Mokshith31/legalbert-contract-clause-classification" style="color:#6b7280;">Legal-BERT + CUAD (41 classes)</a>
+        · Dataset: <a href="https://huggingface.co/datasets/theatticusproject/cuad-qa" style="color:#6b7280;">CUAD</a>
+        · <a href="https://huggingface.co/spaces/gaurv007/ClauseGuard" style="color:#6b7280;">ClauseGuard Space</a>
+      </p>
+    </div>
+    """)
 
 if __name__ == "__main__":
     demo.launch()

compare.py

@@ -0,0 +1,229 @@
+"""
+ClauseGuard — Contract Comparison Engine
+═══════════════════════════════════════
+Compare two contracts side-by-side:
+  • Clause-level diff (added/removed/modified clauses)
+  • Risk delta (which contract is more favorable)
+  • Alignment score (similarity between documents)
+"""
+
+import re
+from difflib import SequenceMatcher
+from collections import defaultdict
+
+def _normalize_clause(text):
+    """Normalize clause text for comparison."""
+    text = text.lower()
+    text = re.sub(r'[^a-z0-9\s]', ' ', text)
+    text = re.sub(r'\s+', ' ', text).strip()
+    return text
+
+def _clause_similarity(a, b):
+    """Compute similarity between two clauses."""
+    return SequenceMatcher(None, _normalize_clause(a), _normalize_clause(b)).ratio()
+
+def _extract_clause_type(clause_text):
+    """Heuristic clause type detection for alignment."""
+    text_lower = clause_text.lower()
+    type_keywords = {
+        "governing law": ["govern", "law", "jurisdiction"],
+        "termination": ["terminat", "cancel", "end"],
+        "indemnification": ["indemnif", "hold harmless"],
+        "confidentiality": ["confidential", "non-disclosure"],
+        "liability": ["liability", "liable", "damages"],
+        "payment": ["payment", "fee", "price", "compensat"],
+        "intellectual property": ["intellectual", "ip", "copyright", "patent"],
+        "warranty": ["warrant", "guarantee"],
+        "force majeure": ["force majeure", "act of god"],
+        "arbitration": ["arbitrat", "mediation"],
+        "assignment": ["assign", "transfer"],
+        "non-compete": ["compete", "competition"],
+        "renewal": ["renew", "extend"],
+        "effective date": ["effective date", "commencement"],
+    }
+    for ctype, keywords in type_keywords.items():
+        if any(kw in text_lower for kw in keywords):
+            return ctype
+    return "general"
+
+def compare_contracts(text_a, text_b, clauses_a=None, clauses_b=None):
+    """
+    Compare two contract texts and return structural diff.
+
+    Returns dict with:
+      - alignment_score: float 0-1
+      - added_clauses: clauses in B not in A
+      - removed_clauses: clauses in A not in B
+      - modified_clauses: clauses that are similar but different
+      - risk_delta: which contract is riskier
+      - clause_type_map: clauses grouped by type for both docs
+    """
+    if not text_a or not text_b:
+        return {"error": "Both contracts required"}
+
+    # Split into clauses if not provided
+    if clauses_a is None:
+        clauses_a = _split_clauses(text_a)
+    if clauses_b is None:
+        clauses_b = _split_clauses(text_b)
+
+    # Build clause type maps
+    type_map_a = defaultdict(list)
+    type_map_b = defaultdict(list)
+    for c in clauses_a:
+        type_map_a[_extract_clause_type(c)].append(c)
+    for c in clauses_b:
+        type_map_b[_extract_clause_type(c)].append(c)
+
+    # Find matches
+    matched_a = set()
+    matched_b = set()
+    modified = []
+
+    SIMILARITY_THRESHOLD = 0.75
+    MODIFIED_THRESHOLD = 0.45
+
+    for i, ca in enumerate(clauses_a):
+        best_sim = 0
+        best_j = -1
+        for j, cb in enumerate(clauses_b):
+            if j in matched_b:
+                continue
+            sim = _clause_similarity(ca, cb)
+            if sim > best_sim:
+                best_sim = sim
+                best_j = j
+
+        if best_sim >= SIMILARITY_THRESHOLD:
+            matched_a.add(i)
+            matched_b.add(best_j)
+            if best_sim < 0.95:
+                modified.append({
+                    "type": "modified",
+                    "similarity": round(best_sim, 3),
+                    "clause_a": ca[:200],
+                    "clause_b": clauses_b[best_j][:200],
+                    "clause_type": _extract_clause_type(ca),
+                })
+        elif best_sim >= MODIFIED_THRESHOLD:
+            modified.append({
+                "type": "partial",
+                "similarity": round(best_sim, 3),
+                "clause_a": ca[:200],
+                "clause_b": clauses_b[best_j][:200] if best_j >= 0 else "",
+                "clause_type": _extract_clause_type(ca),
+            })
+
+    removed = [clauses_a[i] for i in range(len(clauses_a)) if i not in matched_a]
+    added = [clauses_b[j] for j in range(len(clauses_b)) if j not in matched_b]
+
+    # Compute alignment score
+    total_pairs = max(len(clauses_a), len(clauses_b))
+    if total_pairs > 0:
+        alignment = len(matched_a) / total_pairs
+    else:
+        alignment = 0.0
+
+    # Risk delta: compare length and presence of risk keywords
+    risk_keywords = ["unlimited", "unilateral", "waive", "arbitration", "indemnif",
+                     "not liable", "no warranty", "sole discretion"]
+    risk_a = sum(1 for kw in risk_keywords if kw in text_a.lower())
+    risk_b = sum(1 for kw in risk_keywords if kw in text_b.lower())
+
+    if risk_a > risk_b + 2:
+        risk_delta = "Contract A is significantly riskier"
+        risk_winner = "B"
+    elif risk_b > risk_a + 2:
+        risk_delta = "Contract B is significantly riskier"
+        risk_winner = "A"
+    else:
+        risk_delta = "Similar risk profiles"
+        risk_winner = "tie"
+
+    return {
+        "alignment_score": round(alignment, 3),
+        "contract_a_clauses": len(clauses_a),
+        "contract_b_clauses": len(clauses_b),
+        "added_clauses": [{"text": c[:200], "type": _extract_clause_type(c)} for c in added[:50]],
+        "removed_clauses": [{"text": c[:200], "type": _extract_clause_type(c)} for c in removed[:50]],
+        "modified_clauses": modified[:50],
+        "risk_delta": risk_delta,
+        "risk_winner": risk_winner,
+        "type_map_a": {k: len(v) for k, v in type_map_a.items()},
+        "type_map_b": {k: len(v) for k, v in type_map_b.items()},
+    }
+
+def _split_clauses(text):
+    """Split text into clauses."""
+    text = re.sub(r'\n{3,}', '\n\n', text.strip())
+    parts = re.split(
+        r'(?<=[.!?])\s+(?=[A-Z0-9(])|(?:\n\n)(?=\d+[.)]\s|\([a-z]\)\s|[A-Z][A-Z\s]{2,})',
+        text
+    )
+    return [p.strip() for p in parts if len(p.strip()) > 30]
+
+def render_comparison_html(result):
+    """Render comparison results as HTML for Gradio."""
+    if "error" in result:
+        return f'<p style="color:#dc2626;">{result["error"]}</p>'
+
+    html = f'''
+    <div style="font-family:system-ui,sans-serif;">
+      <div style="display:grid;grid-template-columns:1fr 1fr;gap:12px;margin-bottom:16px;">
+        <div style="padding:12px;border-radius:8px;background:#eff6ff;border:1px solid #bfdbfe;text-align:center;">
+          <div style="font-size:24px;font-weight:700;color:#1d4ed8;">{result["contract_a_clauses"]}</div>
+          <div style="font-size:12px;color:#3b82f6;">Clauses in Contract A</div>
+        </div>
+        <div style="padding:12px;border-radius:8px;background:#fefce8;border:1px solid #fde68a;text-align:center;">
+          <div style="font-size:24px;font-weight:700;color:#a16207;">{result["contract_b_clauses"]}</div>
+          <div style="font-size:12px;color:#ca8a04;">Clauses in Contract B</div>
+        </div>
+      </div>
+
+      <div style="padding:12px;border-radius:8px;background:#f9fafb;border:1px solid #e5e7eb;margin-bottom:16px;text-align:center;">
+        <div style="font-size:28px;font-weight:700;color:#374151;">{result["alignment_score"]*100:.1f}%</div>
+        <div style="font-size:12px;color:#6b7280;">Alignment Score</div>
+      </div>
+
+      <div style="padding:12px;border-radius:8px;background:{
+          "#fef2f2" if result["risk_winner"] != "tie" else "#f0fdf4"
+      };border:1px solid {
+          "#fecaca" if result["risk_winner"] != "tie" else "#bbf7d0"
+      };margin-bottom:16px;text-align:center;">
+        <span style="font-size:14px;font-weight:600;color:{
+            "#dc2626" if result["risk_winner"] != "tie" else "#16a34a"
+        };">⚖️ {result["risk_delta"]}</span>
+      </div>
+    '''
+
+    # Modified clauses
+    if result["modified_clauses"]:
+        html += '<div style="margin-bottom:16px;"><h3 style="font-size:14px;color:#374151;margin-bottom:8px;">📝 Modified Clauses</h3>'
+        for m in result["modified_clauses"][:20]:
+            html += f'''
+            <div style="border:1px solid #e5e7eb;border-radius:6px;padding:10px;margin-bottom:8px;">
+              <div style="font-size:11px;color:#6b7280;margin-bottom:4px;">{m["clause_type"].upper()} · Similarity: {m["similarity"]*100:.0f}%</div>
+              <div style="display:grid;grid-template-columns:1fr 1fr;gap:8px;">
+                <div style="background:#fef2f2;padding:6px;border-radius:4px;font-size:12px;color:#991b1b;">{m["clause_a"][:150]}...</div>
+                <div style="background:#f0fdf4;padding:6px;border-radius:4px;font-size:12px;color:#166534;">{m["clause_b"][:150]}...</div>
+              </div>
+            </div>
+            '''
+        html += '</div>'
+
+    # Added clauses
+    if result["added_clauses"]:
+        html += '<div style="margin-bottom:16px;"><h3 style="font-size:14px;color:#374151;margin-bottom:8px;">➕ Added in Contract B</h3>'
+        for a in result["added_clauses"][:15]:
+            html += f'<div style="background:#f0fdf4;padding:8px;border-radius:4px;font-size:12px;color:#166534;margin-bottom:4px;border-left:3px solid #22c55e;"><b>{a["type"].upper()}</b> · {a["text"][:150]}...</div>'
+        html += '</div>'
+
+    # Removed clauses
+    if result["removed_clauses"]:
+        html += '<div style="margin-bottom:16px;"><h3 style="font-size:14px;color:#374151;margin-bottom:8px;">➖ Removed from Contract A</h3>'
+        for r in result["removed_clauses"][:15]:
+            html += f'<div style="background:#fef2f2;padding:8px;border-radius:4px;font-size:12px;color:#991b1b;margin-bottom:4px;border-left:3px solid #ef4444;"><b>{r["type"].upper()}</b> · {r["text"][:150]}...</div>'
+        html += '</div>'
+
+    html += '</div>'
+    return html

compliance.py

@@ -0,0 +1,245 @@
+"""
+ClauseGuard — Compliance Checker
+════════════════════════════════
+Check contracts against regulatory frameworks:
+  • GDPR (EU General Data Protection Regulation)
+  • CCPA (California Consumer Privacy Act)
+  • SOX (Sarbanes-Oxley)
+  • HIPAA (Health Insurance Portability and Accountability Act)
+  • FINRA (Financial Industry Regulatory Authority)
+"""
+
+import re
+from collections import defaultdict
+
+# Regulatory requirement definitions
+REGULATIONS = {
+    "GDPR": {
+        "description": "EU General Data Protection Regulation (Regulation 2016/679)",
+        "requirements": {
+            "lawful_basis": {
+                "keywords": ["lawful basis", "legal basis", "legitimate interest", "consent", "performance of contract", "legal obligation"],
+                "description": "Must specify lawful basis for data processing (Art. 6)",
+                "severity": "HIGH",
+            },
+            "data_subject_rights": {
+                "keywords": ["right to access", "right to erasure", "right to be forgotten", "data portability", "rectification", "object to processing"],
+                "description": "Must acknowledge data subject rights (Arts. 15-22)",
+                "severity": "HIGH",
+            },
+            "data_breach_notification": {
+                "keywords": ["data breach", "breach notification", "notify supervisory authority", "72 hours"],
+                "description": "Must include data breach notification obligations (Art. 33)",
+                "severity": "MEDIUM",
+            },
+            "data_protection_officer": {
+                "keywords": ["data protection officer", "DPO"],
+                "description": "Should reference Data Protection Officer if applicable (Art. 37)",
+                "severity": "LOW",
+            },
+            "cross_border_transfer": {
+                "keywords": ["standard contractual clauses", "SCCs", "adequacy decision", "transfer mechanism", "third country"],
+                "description": "Must specify transfer safeguards for cross-border data (Arts. 44-49)",
+                "severity": "HIGH",
+            },
+            "privacy_by_design": {
+                "keywords": ["privacy by design", "privacy by default", "data minimization", "purpose limitation"],
+                "description": "Should reference privacy-by-design principles (Art. 25)",
+                "severity": "MEDIUM",
+            },
+        },
+    },
+    "CCPA": {
+        "description": "California Consumer Privacy Act (Cal. Civ. Code § 1798.100 et seq.)",
+        "requirements": {
+            "consumer_rights": {
+                "keywords": ["right to know", "right to delete", "right to opt out", "right to non-discrimination", "consumer rights"],
+                "description": "Must acknowledge California consumer rights",
+                "severity": "HIGH",
+            },
+            "data_categories": {
+                "keywords": ["categories of personal information", "personal information categories", "identifiers", "commercial information"],
+                "description": "Must disclose categories of personal information collected",
+                "severity": "HIGH",
+            },
+            "sale_of_data": {
+                "keywords": ["do not sell my personal information", "opt-out of sale", "sale of personal information"],
+                "description": "Must provide opt-out mechanism for data sales",
+                "severity": "HIGH",
+            },
+            "service_providers": {
+                "keywords": ["service provider", "third party", "contractor", "business purpose"],
+                "description": "Should limit data use to business/service provider purposes",
+                "severity": "MEDIUM",
+            },
+        },
+    },
+    "SOX": {
+        "description": "Sarbanes-Oxley Act (US, 2002)",
+        "requirements": {
+            "internal_controls": {
+                "keywords": ["internal controls", "internal control over financial reporting", "ICFR"],
+                "description": "Must reference internal controls over financial reporting (§ 404)",
+                "severity": "HIGH",
+            },
+            "audit_committee": {
+                "keywords": ["audit committee", "independent auditor", "PCAOB"],
+                "description": "Should reference audit committee oversight",
+                "severity": "MEDIUM",
+            },
+            "whistleblower": {
+                "keywords": ["whistleblower", "anonymous reporting", "reporting hotline", "retaliation"],
+                "description": "Should protect whistleblower provisions (§ 806)",
+                "severity": "HIGH",
+            },
+            "document_retention": {
+                "keywords": ["document retention", "record retention", "retention policy", "preserve records"],
+                "description": "Must include document retention obligations (§ 802)",
+                "severity": "HIGH",
+            },
+        },
+    },
+    "HIPAA": {
+        "description": "Health Insurance Portability and Accountability Act (US, 1996)",
+        "requirements": {
+            "phi_protection": {
+                "keywords": ["protected health information", "PHI", "health information", "ePHI"],
+                "description": "Must protect PHI and limit uses/disclosures",
+                "severity": "CRITICAL",
+            },
+            "business_associate": {
+                "keywords": ["business associate agreement", "BAA", "business associate", "covered entity"],
+                "description": "Should reference Business Associate Agreement (§ 164.504(e))",
+                "severity": "HIGH",
+            },
+            "security_safeguards": {
+                "keywords": ["administrative safeguards", "technical safeguards", "physical safeguards", "encryption", "access controls"],
+                "description": "Must implement security safeguards (§ 164.308-312)",
+                "severity": "HIGH",
+            },
+            "breach_notification": {
+                "keywords": ["breach notification", "notification of breach", "unauthorized access"],
+                "description": "Must include breach notification obligations (§ 164.400-414)",
+                "severity": "HIGH",
+            },
+        },
+    },
+    "FINRA": {
+        "description": "Financial Industry Regulatory Authority (US)",
+        "requirements": {
+            "recordkeeping": {
+                "keywords": ["recordkeeping", "books and records", "retain records", "SEC Rule 17a-4"],
+                "description": "Must comply with recordkeeping rules (FINRA Rule 4511)",
+                "severity": "HIGH",
+            },
+            "supervision": {
+                "keywords": ["supervision", "supervisory system", "review and approval"],
+                "description": "Should reference supervisory obligations (FINRA Rule 3110)",
+                "severity": "MEDIUM",
+            },
+            "anti_money_laundering": {
+                "keywords": ["anti-money laundering", "AML", "suspicious activity", "SAR", "OFAC"],
+                "description": "Must reference AML compliance (FINRA Rule 3310)",
+                "severity": "HIGH",
+            },
+            "privacy": {
+                "keywords": ["privacy policy", "customer information", "Regulation S-P", "nonpublic personal information"],
+                "description": "Must protect customer information (Regulation S-P)",
+                "severity": "HIGH",
+            },
+        },
+    },
+}
+
+RISK_STYLES = {
+    "CRITICAL": ("#dc2626", "#fef2f2"),
+    "HIGH": ("#ea580c", "#fff7ed"),
+    "MEDIUM": ("#ca8a04", "#fefce8"),
+    "LOW": ("#16a34a", "#f0fdf4"),
+}
+
+
+def check_compliance(text):
+    """Check contract text against all regulatory frameworks."""
+    text_lower = text.lower()
+    results = {}
+
+    for reg_name, reg_data in REGULATIONS.items():
+        checks = []
+        for req_name, req_data in reg_data["requirements"].items():
+            matched = False
+            matched_keywords = []
+            for kw in req_data["keywords"]:
+                if kw.lower() in text_lower:
+                    matched = True
+                    matched_keywords.append(kw)
+            checks.append({
+                "requirement": req_name,
+                "description": req_data["description"],
+                "severity": req_data["severity"],
+                "status": "PASS" if matched else "MISSING",
+                "matched_keywords": matched_keywords,
+            })
+
+        passed = sum(1 for c in checks if c["status"] == "PASS")
+        total = len(checks)
+        compliance_rate = round(passed / total * 100) if total > 0 else 0
+
+        results[reg_name] = {
+            "description": reg_data["description"],
+            "compliance_rate": compliance_rate,
+            "checks": checks,
+            "overall_status": "COMPLIANT" if compliance_rate >= 80 else "PARTIAL" if compliance_rate >= 40 else "NON-COMPLIANT",
+        }
+
+    return results
+
+
+def render_compliance_html(results):
+    """Render compliance results as HTML for Gradio."""
+    html = '<div style="font-family:system-ui,sans-serif;">'
+
+    for reg_name, reg_result in results.items():
+        rate = reg_result["compliance_rate"]
+        status = reg_result["overall_status"]
+        status_color = "#16a34a" if status == "COMPLIANT" else "#ca8a04" if status == "PARTIAL" else "#dc2626"
+        status_bg = "#f0fdf4" if status == "COMPLIANT" else "#fefce8" if status == "PARTIAL" else "#fef2f2"
+
+        html += f'''
+        <div style="border:1px solid #e5e7eb;border-radius:10px;margin-bottom:16px;overflow:hidden;">
+          <div style="display:flex;justify-content:space-between;align-items:center;padding:12px 16px;background:{status_bg};border-bottom:1px solid #e5e7eb;">
+            <div>
+              <span style="font-size:16px;font-weight:700;color:#1f2937;">{reg_name}</span>
+              <p style="font-size:11px;color:#6b7280;margin:2px 0 0 0;">{reg_result["description"]}</p>
+            </div>
+            <div style="text-align:right;">
+              <div style="font-size:24px;font-weight:700;color:{status_color};">{rate}%</div>
+              <div style="font-size:11px;color:{status_color};font-weight:500;">{status}</div>
+            </div>
+          </div>
+          <div style="padding:8px 16px;">
+        '''
+
+        for check in reg_result["checks"]:
+            color, bg = RISK_STYLES[check["severity"]]
+            status_icon = "✅" if check["status"] == "PASS" else "❌"
+            status_text = "Found" if check["status"] == "PASS" else "Missing"
+            keywords = ", ".join(check["matched_keywords"][:3]) if check["matched_keywords"] else "—"
+
+            html += f'''
+            <div style="display:flex;justify-content:space-between;align-items:flex-start;padding:8px 0;border-bottom:1px solid #f3f4f6;">
+              <div style="flex:1;">
+                <div style="font-size:12px;font-weight:500;color:#374151;">{check["description"]}</div>
+                <div style="font-size:10px;color:#9ca3af;margin-top:2px;">Keywords: {keywords}</div>
+              </div>
+              <div style="display:flex;align-items:center;gap:6px;margin-left:8px;">
+                <span style="font-size:10px;color:{color};font-weight:600;background:{bg};padding:2px 8px;border-radius:4px;">{check["severity"]}</span>
+                <span style="font-size:13px;">{status_icon}</span>
+              </div>
+            </div>
+            '''
+
+        html += '</div></div>'
+
+    html += '</div>'
+    return html

obligations.py

@@ -0,0 +1,190 @@
+"""
+ClauseGuard — Obligation Tracker
+═══════════════════════════════
+Extract action items, deadlines, and obligations from contracts.
+Categorize: monetary, compliance, reporting, delivery
+"""
+
+import re
+from collections import defaultdict
+from datetime import datetime, timedelta
+
+# Obligation keywords by category
+OBLIGATION_PATTERNS = {
+    "monetary": [
+        r"(?:shall|must|will|agrees? to)\s+pay\s+(?:\$?[\d,]+(?:\.\d{2})?)",
+        r"(?:fee|payment|compensation|reimburs(?:e|ement))\s+of\s+(?:\$?[\d,]+(?:\.\d{2})?)",
+        r"(?:shall|must|will)\s+remit\s+(?:\$?[\d,]+(?:\.\d{2})?)",
+        r"(?:annual|monthly|quarterly)\s+(?:fee|payment)\s+of",
+        r"(?:liquidated damages|penalty)\s+of\s+(?:\$?[\d,]+(?:\.\d{2})?)",
+    ],
+    "compliance": [
+        r"(?:shall|must|will)\s+comply\s+with",
+        r"(?:shall|must|will)\s+adhere\s+to",
+        r"(?:shall|must|will)\s+conform\s+to",
+        r"(?:shall|must|will)\s+follow\s+(?:the|all)\s+(?:applicable|relevant)\s+(?:laws|regulations|standards)",
+        r"(?:GDPR|CCPA|HIPAA|SOX|PCI-DSS|ISO\s+\d+)",
+        r"(?:confidential|privacy|data protection)",
+        r"(?:shall|must|will)\s+obtain\s+(?:necessary|required)\s+(?:approvals?|permits?|licenses?)",
+        r"(?:shall|must|will)\s+maintain\s+(?:insurance|coverage|bond)",
+    ],
+    "reporting": [
+        r"(?:shall|must|will)\s+report",
+        r"(?:shall|must|will)\s+provide\s+(?:regular|monthly|quarterly|annual)\s+(?:reports?|updates?|status)",
+        r"(?:shall|must|will)\s+notify",
+        r"(?:shall|must|will)\s+inform",
+        r"(?:shall|must|will)\s+deliver\s+(?:a|an|the)\s+report",
+        r"(?:audit|inspection)\s+(?:reports?|rights?)",
+    ],
+    "delivery": [
+        r"(?:shall|must|will)\s+deliver",
+        r"(?:shall|must|will)\s+provide",
+        r"(?:shall|must|will)\s+furnish",
+        r"(?:shall|must|will)\s+supply",
+        r"(?:shall|must|will)\s+submit",
+        r"(?:delivery|performance)\s+(?:date|schedule|timeline)",
+        r"(?:within|no later than|by)\s+(?:\d+)\s+(?:days?|weeks?|months?|years?)",
+    ],
+    "termination": [
+        r"(?:shall|must|will)\s+return",
+        r"(?:shall|must|will)\s+destroy",
+        r"(?:shall|must|will)\s+cease",
+        r"(?:upon|after)\s+termination",
+        r"(?:post-termination|surviving)\s+obligations?",
+    ],
+}
+
+# Timeframe extraction
+TIME_PATTERNS = [
+    (r"within\s+(\d+)\s+(day|week|month|year)s?", "relative"),
+    (r"no\s+later\s+than\s+(\d+)\s+(day|week|month|year)s?", "relative"),
+    (r"within\s+(\d+)\s+business\s+days?", "business_days"),
+    (r"by\s+([A-Z][a-z]+\s+\d{1,2},?\s+\d{4})", "absolute"),
+    (r"on\s+or\s+before\s+([A-Z][a-z]+\s+\d{1,2},?\s+\d{4})", "absolute"),
+    (r"(\d{1,2}/\d{1,2}/\d{2,4})", "absolute_date"),
+    (r"(\d{1,2}-\d{1,2}-\d{2,4})", "absolute_date"),
+]
+
+PARTY_PATTERNS = [
+    r"\b(?:Party A|Party B|Disclosing Party|Receiving Party|Licensor|Licensee|Buyer|Seller|Tenant|Landlord|Employer|Employee|Company|Customer|Vendor|Client)\b",
+    r"\b[A-Z][A-Za-z0-9\s&]+(?:Inc\.?|LLC|Ltd\.?|Limited|Corp\.?|Corporation|PLC|GmbH|AG|S\.A\.?|B\.V\.)\b",
+]
+
+
+def extract_obligations(text):
+    """Extract obligations from contract text."""
+    obligations = []
+
+    # Split into sentences
+    sentences = re.split(r'(?<=[.!?])\s+(?=[A-Z])', text)
+
+    for sentence in sentences:
+        sentence = sentence.strip()
+        if len(sentence) < 30:
+            continue
+
+        found_types = set()
+        for otype, patterns in OBLIGATION_PATTERNS.items():
+            for pat in patterns:
+                if re.search(pat, sentence, re.IGNORECASE):
+                    found_types.add(otype)
+                    break
+
+        if not found_types:
+            continue
+
+        # Extract party
+        party = "Unknown"
+        for pp in PARTY_PATTERNS:
+            m = re.search(pp, sentence)
+            if m:
+                party = m.group(0)
+                break
+
+        # Extract timeframe
+        deadline = "Not specified"
+        for pat, ptype in TIME_PATTERNS:
+            m = re.search(pat, sentence, re.IGNORECASE)
+            if m:
+                if ptype == "relative":
+                    num = m.group(1)
+                    unit = m.group(2)
+                    deadline = f"Within {num} {unit}(s)"
+                elif ptype == "business_days":
+                    num = m.group(1)
+                    deadline = f"Within {num} business day(s)"
+                elif ptype in ("absolute", "absolute_date"):
+                    deadline = m.group(1)
+                break
+
+        for otype in found_types:
+            obligations.append({
+                "type": otype,
+                "party": party,
+                "description": sentence[:250] + ("..." if len(sentence) > 250 else ""),
+                "deadline": deadline,
+                "full_text": sentence,
+            })
+
+    return obligations
+
+
+def render_obligations_html(obligations):
+    """Render obligations as HTML cards for Gradio."""
+    if not obligations:
+        return '<div style="padding:16px;color:#6b7280;text-align:center;">No obligations detected.</div>'
+
+    # Group by type
+    grouped = defaultdict(list)
+    for ob in obligations:
+        grouped[ob["type"]].append(ob)
+
+    type_icons = {
+        "monetary": "💰",
+        "compliance": "⚖️",
+        "reporting": "📊",
+        "delivery": "📦",
+        "termination": "🛑",
+    }
+    type_colors = {
+        "monetary": "#22c55e",
+        "compliance": "#f59e0b",
+        "reporting": "#3b82f6",
+        "delivery": "#8b5cf6",
+        "termination": "#ef4444",
+    }
+
+    html = '<div style="font-family:system-ui,sans-serif;">'
+
+    # Summary counts
+    html += '<div style="display:grid;grid-template-columns:repeat(auto-fit,minmax(120px,1fr));gap:8px;margin-bottom:16px;">'
+    for otype, obs in sorted(grouped.items()):
+        color = type_colors.get(otype, "#6b7280")
+        icon = type_icons.get(otype, "📋")
+        html += f'''
+        <div style="text-align:center;padding:10px;border-radius:8px;background:{color}15;border:1px solid {color}30;">
+          <div style="font-size:20px;">{icon}</div>
+          <div style="font-size:20px;font-weight:700;color:{color};">{len(obs)}</div>
+          <div style="font-size:11px;color:{color};text-transform:capitalize;">{otype}</div>
+        </div>
+        '''
+    html += '</div>'
+
+    # Individual cards
+    for otype, obs in sorted(grouped.items()):
+        color = type_colors.get(otype, "#6b7280")
+        icon = type_icons.get(otype, "📋")
+        html += f'<h3 style="font-size:14px;color:#374151;margin:16px 0 8px 0;border-bottom:2px solid {color}30;padding-bottom:4px;">{icon} {otype.title()} Obligations</h3>'
+        for ob in obs:
+            html += f'''
+            <div style="border:1px solid #e5e7eb;border-left:4px solid {color};border-radius:6px;padding:10px;margin-bottom:8px;background:#fafafa;">
+              <div style="display:flex;justify-content:space-between;align-items:center;margin-bottom:4px;">
+                <span style="font-size:12px;font-weight:600;color:{color};">{ob["party"]}</span>
+                <span style="font-size:11px;color:#6b7280;background:#f3f4f6;padding:2px 8px;border-radius:4px;">{ob["deadline"]}</span>
+              </div>
+              <p style="font-size:12px;color:#4b5563;margin:0;line-height:1.5;">{ob["description"]}</p>
+            </div>
+            '''
+
+    html += '</div>'
+    return html

requirements.txt

@@ -1,4 +1,11 @@
-gradio>=5.0
-transformers>=5.0
-torch
-numpy
+gradio>=5.23.0
+transformers>=5.6.1
+torch>=2.5.0
+numpy>=2.0.0
+pdfplumber>=0.11.0
+python-docx>=1.1.0
+spacy>=3.8.0
+scikit-learn>=1.6.0
+peft>=0.15.0
+accelerate>=1.2.0
+pandas>=2.2.0