Spaces:

gaurv007
/

ClauseGuard

Sleeping

App Files Files Community

anky2002 commited on 16 days ago

Commit

3c5a789

2 Parent(s): 51ac51a 6277262

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

Browse files

Files changed (10) hide show

api/main.py +529 -126
api/requirements.txt +2 -0
web/app/api/analyze/route.ts +2 -17
web/app/api/compare/route.ts +33 -0
web/app/dashboard-pages/analyze/page.tsx +306 -121
web/app/dashboard-pages/compare/page.tsx +283 -0
web/app/dashboard-pages/dashboard/page.tsx +80 -10
web/app/page.tsx +72 -37
web/components/nav.tsx +3 -1
web/lib/supabase/schema.sql +11 -4

api/main.py CHANGED Viewed

@@ -1,18 +1,28 @@
 """
-ClauseGuard — FastAPI Backend (Production)
-Clause classification + explanations + history + JWT auth.
-FastAPI 0.136, Pydantic 2.13, Python 3.12 (April 2026)
 """
 import os
-import time
 import re
 from contextlib import asynccontextmanager
 from typing import Optional
 import httpx
 import numpy as np
-from fastapi import FastAPI, HTTPException, Depends
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel, Field
@@ -27,12 +37,50 @@ SUPABASE_SERVICE_KEY = os.environ.get("SUPABASE_SERVICE_ROLE_KEY", "")
 HF_API_TOKEN = os.environ.get("HF_API_TOKEN", "")
 SAULLM_ENDPOINT = os.environ.get("SAULLM_ENDPOINT", "")
-LABEL_NAMES = [
-    "Limitation of liability", "Unilateral termination", "Unilateral change",
-    "Content removal", "Contract by using", "Choice of law", "Jurisdiction", "Arbitration",
 ]
-LABEL_DESCRIPTIONS = {
     "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.",
@@ -41,79 +89,93 @@ LABEL_DESCRIPTIONS = {
     "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.",
 }
-SEVERITY_MAP = {
-    "Limitation of liability": "HIGH", "Unilateral termination": "HIGH", "Arbitration": "HIGH",
-    "Unilateral change": "MEDIUM", "Content removal": "MEDIUM", "Choice of law": "MEDIUM",
-    "Jurisdiction": "MEDIUM", "Contract by using": "LOW",
 }
-LEGAL_BASIS = {
-    "Arbitration": "EU Directive 93/13/EEC Art. 3; CFPB arbitration rule (US).",
-    "Unilateral change": "EU Directive 93/13/EEC Annex 1(j) — unilateral alteration.",
-    "Content removal": "EU Digital Services Act Art. 17 — statement of reasons required.",
-    "Jurisdiction": "EU Regulation 1215/2012 Art. 18 — consumer domicile prevails.",
-    "Choice of law": "EU Regulation 593/2008 Art. 6 — consumer protection of habitual residence.",
-    "Limitation of liability": "EU Directive 93/13/EEC Annex 1(a) — excluding statutory rights.",
-    "Unilateral termination": "EU Directive 93/13/EEC Annex 1(f)(g) — termination without notice.",
-    "Contract by using": "EU Directive 2011/83/EU Art. 8 — active consent required.",
-}
-# ─── Model ───
-classifier = None
 def load_model():
-    global classifier
     try:
-        if USE_ONNX and os.path.exists(ONNX_MODEL_PATH):
-            from optimum.onnxruntime import ORTModelForSequenceClassification
-            from transformers import AutoTokenizer, pipeline
-            model = ORTModelForSequenceClassification.from_pretrained(ONNX_MODEL_PATH)
-            tokenizer = AutoTokenizer.from_pretrained(ONNX_MODEL_PATH)
-            classifier = pipeline("text-classification", model=model, tokenizer=tokenizer, top_k=None)
-        elif os.path.exists(MODEL_PATH):
-            from transformers import pipeline
-            classifier = pipeline("text-classification", model=MODEL_PATH, top_k=None, device=-1)
     except Exception as e:
-        print(f"Model load failed: {e}")
-# ─── Regex fallback ───
-PATTERNS = {
-    0: [r"not liable", r"shall not be (liable|responsible)", r"in no event.*liable", r"limitation of liability", r"without warranty", r"disclaim"],
-    1: [r"terminat.*at any time", r"suspend.*account.*without", r"we may (terminat|suspend|discontinu)", r"right to (terminat|suspend)"],
-    2: [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)"],
-    3: [r"remove.*content.*without", r"right to remove", r"we may.*remove"],
-    4: [r"by (using|accessing).*you agree", r"continued use.*constitutes? acceptance"],
-    5: [r"governed by.*laws? of", r"shall be governed", r"laws of the state of"],
-    6: [r"exclusive jurisdiction", r"courts? of.*(california|delaware|new york|ireland|england)", r"submit to.*jurisdiction"],
-    7: [r"arbitrat", r"binding arbitration", r"waive.*right.*court", r"class action waiver"],
-}
-def classify_clause(text: str) -> list[dict]:
-    if classifier:
-        try:
-            preds = classifier(text, truncation=True, max_length=512)
-            items = preds[0] if isinstance(preds[0], list) else preds
-            return [
-                {"name": p["label"], "severity": SEVERITY_MAP.get(p["label"], "MEDIUM"),
-                 "description": LABEL_DESCRIPTIONS.get(p["label"], ""), "confidence": round(p["score"], 3)}
-                for p in items if p["score"] > 0.5 and p["label"] in LABEL_DESCRIPTIONS
-            ]
-        except Exception:
-            pass
-    # Regex fallback
-    results = []
-    text_lower = text.lower()
-    for lid, pats in PATTERNS.items():
-        for p in pats:
-            if re.search(p, text_lower):
-                name = LABEL_NAMES[lid]
-                results.append({"name": name, "severity": SEVERITY_MAP[name],
-                                "description": LABEL_DESCRIPTIONS[name], "confidence": 0.7})
-                break
-    return results
 # ─── Supabase helper ───
 async def supabase_insert(table: str, data: dict):
@@ -138,9 +200,348 @@ async def supabase_query(table: str, params: dict, headers_extra: dict = {}):
         )
         return resp.json() if resp.status_code == 200 else []
 # ─── Models ───
 class AnalyzeRequest(BaseModel):
-    clauses: list[str] = Field(..., min_length=1, max_length=500)
     source_url: Optional[str] = None
 class AnalyzeResponse(BaseModel):
@@ -149,9 +550,17 @@ class AnalyzeResponse(BaseModel):
     total_clauses: int
     flagged_count: int
     results: list[dict]
     model: str
     latency_ms: int
 class ExplainRequest(BaseModel):
     clause: str = Field(..., min_length=10, max_length=2000)
     category: str
@@ -169,73 +578,72 @@ async def lifespan(app: FastAPI):
     load_model()
     yield
-app = FastAPI(title="ClauseGuard API", version="1.0.0", lifespan=lifespan)
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["https://clauseguardweb.netlify.app", "https://clauseguardweb.netlify.app", "chrome-extension://*", "http://localhost:3000"],
     allow_credentials=True, allow_methods=["*"], allow_headers=["*"],
 )
 @app.get("/health")
 async def health():
-    return {"status": "ok", "model": "ml" if classifier else "regex"}
 @app.post("/api/analyze", response_model=AnalyzeResponse)
 async def analyze(req: AnalyzeRequest, user: Optional[dict] = Depends(get_current_user)):
     start = time.time()
-    results = [{"text": c, "categories": classify_clause(c)} for c in req.clauses]
-    flagged = [r for r in results if r["categories"]]
-    sev = {"HIGH": 0, "MEDIUM": 0, "LOW": 0}
-    for r in flagged:
-        for c in r["categories"]:
-            sev[c.get("severity", "LOW")] += 1
-    total = len(req.clauses)
-    risk = min(100, round((sev["HIGH"] * 20 + sev["MEDIUM"] * 10 + sev["LOW"] * 5) / max(1, total) * 100))
-    grade = "F" if risk >= 60 else "D" if risk >= 40 else "C" if risk >= 20 else "B" if risk >= 10 else "A"
     latency = int((time.time() - start) * 1000)
-    # Save to DB if authenticated
     if user:
         await supabase_insert("analyses", {
-            "user_id": user["id"], "source_url": req.source_url, "total_clauses": total,
-            "flagged_count": len(flagged), "risk_score": risk, "grade": grade, "clauses": results,
         })
-    return AnalyzeResponse(risk_score=risk, grade=grade, total_clauses=total,
-                           flagged_count=len(flagged), results=results,
-                           model="ml" if classifier else "regex", latency_ms=latency)
 @app.post("/api/explain", response_model=ExplainResponse)
 async def explain(req: ExplainRequest, user: dict = Depends(require_auth)):
-    desc = LABEL_DESCRIPTIONS.get(req.category, "Unknown category.")
-    legal = LEGAL_BASIS.get(req.category, "Consult local consumer protection laws.")
     recommendation = "Review this clause carefully. Consider negotiating or seeking legal advice before agreeing."
-    # Try SaulLM-7B if endpoint configured
     if SAULLM_ENDPOINT and HF_API_TOKEN:
         try:
-            prompt = f"""You are a consumer protection legal analyst. Analyze this clause and explain why it may be unfair.
-Clause: "{req.clause}"
-Category: {req.category}
-Provide:
-1. A plain-English explanation of why this is problematic
-2. The specific legal basis (EU/US consumer protection law)
-3. A practical recommendation for the consumer
-Be concise. 3-4 sentences maximum per section."""
             async with httpx.AsyncClient(timeout=30.0) as client:
-                resp = await client.post(
-                    SAULLM_ENDPOINT,
-                    json={"inputs": prompt, "parameters": {"max_new_tokens": 300, "temperature": 0.3}},
-                    headers={"Authorization": f"Bearer {HF_API_TOKEN}"},
-                )
                 if resp.status_code == 200:
                     output = resp.json()
                     generated = output[0]["generated_text"] if isinstance(output, list) else output.get("generated_text", "")
@@ -245,18 +653,13 @@ Be concise. 3-4 sentences maximum per section."""
                         legal = parts[1] if len(parts) > 1 else legal
                         recommendation = parts[2] if len(parts) > 2 else recommendation
         except Exception:
-            pass  # Fall back to static responses
-    return ExplainResponse(clause=req.clause, category=req.category,
-                           explanation=desc, legal_basis=legal, recommendation=recommendation)
 @app.get("/api/history")
 async def history(user: dict = Depends(require_auth), limit: int = 20, offset: int = 0):
     limit = min(limit, 100)
-    data = await supabase_query("analyses", {
-        "user_id": f"eq.{user['id']}", "select": "*",
-        "order": "created_at.desc", "limit": str(limit), "offset": str(offset),
-    })
     return {"analyses": data, "limit": limit, "offset": offset}
 if __name__ == "__main__":

 """
+ClauseGuard — FastAPI Backend v2.0
+══════════════════════════════════
+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
+  • Obligation tracker
+  • Compliance checker (GDPR, CCPA, SOX, HIPAA, FINRA)
 """
 import os
 import re
+import json
+import time
 from contextlib import asynccontextmanager
 from typing import Optional
+from collections import defaultdict
+from datetime import datetime
 import httpx
 import numpy as np
+from fastapi import FastAPI, HTTPException, Depends, Body
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel, Field
 HF_API_TOKEN = os.environ.get("HF_API_TOKEN", "")
 SAULLM_ENDPOINT = os.environ.get("SAULLM_ENDPOINT", "")
+# ─── CUAD Labels (41 categories) ───
+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"
 ]
+RISK_MAP = {
+    "Uncapped Liability": "CRITICAL", "Arbitration": "CRITICAL",
+    "IP Ownership Assignment": "CRITICAL", "Termination for Convenience": "CRITICAL",
+    "Limitation of liability": "CRITICAL", "Unilateral termination": "CRITICAL",
+    "Liquidated Damages": "CRITICAL",
+    "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",
+    "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",
+    "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",
+}
+DESC_MAP = {
     "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.",
     "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}
+# ─── Regex patterns (fallback) ───
+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)"],
+    "Content removal": [r"remove.*content.*without", r"right to remove", r"we may.*remove"],
+    "Contract by using": [r"by (using|accessing).*you agree", r"continued use.*constitutes? acceptance"],
+    "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"],
 }
+# ─── Model Loading ───
+cuad_tokenizer = None
+cuad_model = None
+_HAS_TORCH = False
+try:
+    import torch
+    from transformers import AutoTokenizer, AutoModelForSequenceClassification
+    from peft import PeftModel
+    _HAS_TORCH = True
+except Exception:
+    pass
 def load_model():
+    global cuad_tokenizer, cuad_model, classifier
+    if not _HAS_TORCH:
+        print("[ClauseGuard] PyTorch not available")
+        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
 # ─── Supabase helper ───
 async def supabase_insert(table: str, data: dict):
         )
         return resp.json() if resp.status_code == 200 else []
+# ─── Clause Processing ───
+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)
+    return [p.strip() for p in parts if len(p.strip()) > 30]
+def classify_regex(text):
+    text_lower = text.lower()
+    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 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]
+                results.append({
+                    "label": label,
+                    "confidence": round(float(prob), 3),
+                    "risk": RISK_MAP.get(label, "LOW"),
+                    "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:
+        return classify_regex(clause_text)
+# ─── NER ───
+def extract_entities(text):
+    entities = []
+    # Dates
+    for pat, etype in [
+        (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 m in re.finditer(pat, text, re.IGNORECASE):
+            entities.append({"text": m.group(), "type": etype, "start": m.start(), "end": m.end()})
+    # Money
+    for pat, etype in [
+        (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 m in re.finditer(pat, text, re.IGNORECASE):
+            entities.append({"text": m.group(), "type": etype, "start": m.start(), "end": m.end()})
+    # Parties
+    for pat, etype in [
+        (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 m in re.finditer(pat, text):
+            entities.append({"text": m.group(), "type": etype, "start": m.start(), "end": m.end()})
+    # Jurisdictions
+    for pat, etype in [
+        (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 m in re.finditer(pat, text, re.IGNORECASE):
+            entities.append({"text": m.group(), "type": etype, "start": m.start(), "end": m.end()})
+    # Defined Terms
+    for pat, etype in [
+        (r'"([A-Z][A-Z\s]+)"', "DEFINED_TERM"),
+        (r'\(([A-Z][A-Z\s]+)\)', "DEFINED_TERM"),
+    ]:
+        for m in re.finditer(pat, text):
+            entities.append({"text": m.group(1), "type": etype, "start": m.start(), "end": m.end()})
+    # Deduplicate
+    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
+# ─── Contradictions ───
+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))})
+    for cc in ["Governing Law", "Termination for Convenience", "Limitation of liability", "Arbitration"]:
+        if cc not in labels_found:
+            contradictions.append({"type": "MISSING", "explanation": f"Critical clause '{cc}' not detected.", "severity": "MEDIUM", "clauses": [cc]})
+    return contradictions
+# ─── 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
+# ─── Obligations ───
+OBLIGATION_PATTERNS = {
+    "monetary": [r"(?:shall|must|will|agrees? to)\s+pay\s+(?:\$?[\d,]+)", r"(?:fee|payment|compensation|reimburs(?:e|ement))\s+of\s+(?:\$?[\d,]+)", r"(?:shall|must|will)\s+remit\s+(?:\$?[\d,]+)", r"(?:annual|monthly|quarterly)\s+(?:fee|payment)\s+of", r"(?:liquidated damages|penalty)\s+of\s+(?:\$?[\d,]+)"],
+    "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"(?:GDPR|CCPA|HIPAA|SOX|PCI-DSS|ISO\s+\d+)", r"(?:confidential|privacy|data protection)", 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"],
+    "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"],
+    "termination": [r"(?:shall|must|will)\s+return", r"(?:shall|must|will)\s+destroy", r"(?:shall|must|will)\s+cease", r"(?:upon|after)\s+termination"],
+}
+def extract_obligations(text):
+    sentences = re.split(r'(?<=[.!?])\s+(?=[A-Z])', text)
+    obligations = []
+    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
+        party = "Unknown"
+        for pp in [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']:
+            m = re.search(pp, sentence)
+            if m:
+                party = m.group(0)
+                break
+        deadline = "Not specified"
+        for pat, ptype in [
+            (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"),
+        ]:
+            m = re.search(pat, sentence, re.IGNORECASE)
+            if m:
+                deadline = m.group(0)
+                break
+        for otype in found_types:
+            obligations.append({"type": otype, "party": party, "description": sentence[:250] + ("..." if len(sentence) > 250 else ""), "deadline": deadline})
+    return obligations
+# ─── Compliance ───
+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"},
+            "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"},
+        },
+    },
+    "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"},
+        },
+    },
+    "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"},
+            "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"},
+            "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"},
+            "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"},
+        },
+    },
+}
+def check_compliance(text):
+    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
+# ─── Comparison ───
+from difflib import SequenceMatcher
+def _normalize(text):
+    text = text.lower()
+    text = re.sub(r'[^a-z0-9\s]', ' ', text)
+    text = re.sub(r'\s+', ' ', text).strip()
+    return text
+def _clause_type(text):
+    text_lower = 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"],
+    }
+    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 = split_clauses(text_a)
+    clauses_b = split_clauses(text_b)
+    matched_a = set()
+    matched_b = set()
+    modified = []
+    for i, ca in enumerate(clauses_a):
+        best_sim, best_j = 0, -1
+        for j, cb in enumerate(clauses_b):
+            if j in matched_b:
+                continue
+            sim = SequenceMatcher(None, _normalize(ca), _normalize(cb)).ratio()
+            if sim > best_sim:
+                best_sim = sim
+                best_j = j
+        if best_sim >= 0.75:
+            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": _clause_type(ca)})
+        elif best_sim >= 0.45:
+            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": _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]
+    total_pairs = max(len(clauses_a), len(clauses_b))
+    alignment = len(matched_a) / total_pairs if total_pairs > 0 else 0.0
+    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, risk_winner = "Contract A is significantly riskier", "B"
+    elif risk_b > risk_a + 2:
+        risk_delta, risk_winner = "Contract B is significantly riskier", "A"
+    else:
+        risk_delta, risk_winner = "Similar risk profiles", "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": _clause_type(c)} for c in added[:50]],
+        "removed_clauses": [{"text": c[:200], "type": _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 defaultdict(list, [("general", [])]).items()},
+        "type_map_b": {k: len(v) for k, v in defaultdict(list, [("general", [])]).items()},
+    }
 # ─── Models ───
 class AnalyzeRequest(BaseModel):
+    text: str = Field(..., min_length=50)
     source_url: Optional[str] = None
 class AnalyzeResponse(BaseModel):
     total_clauses: int
     flagged_count: int
     results: list[dict]
+    entities: list[dict]
+    contradictions: list[dict]
+    obligations: list[dict]
+    compliance: dict
     model: str
     latency_ms: int
+class CompareRequest(BaseModel):
+    text_a: str = Field(..., min_length=50)
+    text_b: str = Field(..., min_length=50)
 class ExplainRequest(BaseModel):
     clause: str = Field(..., min_length=10, max_length=2000)
     category: str
     load_model()
     yield
+app = FastAPI(title="ClauseGuard API", version="2.0.0", lifespan=lifespan)
 app.add_middleware(
     CORSMiddleware,
+    allow_origins=["https://clauseguardweb.netlify.app", "https://clauseguardweb.netlify.app", "chrome-extension://*", "http://localhost:3000", "*"],
     allow_credentials=True, allow_methods=["*"], allow_headers=["*"],
 )
 @app.get("/health")
 async def health():
+    return {"status": "ok", "model": "ml" if cuad_model else "regex", "version": "2.0.0"}
 @app.post("/api/analyze", response_model=AnalyzeResponse)
 async def analyze(req: AnalyzeRequest, user: Optional[dict] = Depends(get_current_user)):
     start = time.time()
+    clauses = split_clauses(req.text)
+    if not clauses:
+        raise HTTPException(status_code=400, detail="No clauses detected in document")
+    clause_results = []
+    for clause in clauses:
+        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(req.text)
+    contradictions = detect_contradictions(clause_results)
+    risk, grade, sev_counts = compute_risk_score(clause_results, len(clauses))
+    obligations = extract_obligations(req.text)
+    compliance = check_compliance(req.text)
     latency = int((time.time() - start) * 1000)
+    results_for_db = [{"text": cr["text"], "categories": [{"name": cr["label"], "severity": cr["risk"], "confidence": cr["confidence"], "description": cr["description"]}]} for cr in clause_results]
     if user:
         await supabase_insert("analyses", {
+            "user_id": user["id"], "source_url": req.source_url, "total_clauses": len(clauses),
+            "flagged_count": len(set(cr["text"] for cr in clause_results)), "risk_score": risk, "grade": grade,
+            "clauses": results_for_db, "entities": entities, "contradictions": contradictions,
+            "obligations": obligations, "compliance": compliance,
         })
+    return AnalyzeResponse(
+        risk_score=risk, grade=grade, total_clauses=len(clauses),
+        flagged_count=len(set(cr["text"] for cr in clause_results)),
+        results=results_for_db, entities=entities, contradictions=contradictions,
+        obligations=obligations, compliance=compliance,
+        model="ml" if cuad_model else "regex", latency_ms=latency,
+    )
+@app.post("/api/compare")
+async def compare(req: CompareRequest):
+    result = compare_contracts(req.text_a, req.text_b)
+    return result
 @app.post("/api/explain", response_model=ExplainResponse)
 async def explain(req: ExplainRequest, user: dict = Depends(require_auth)):
+    desc = DESC_MAP.get(req.category, "Unknown category.")
+    legal = "Consult local consumer protection laws."
     recommendation = "Review this clause carefully. Consider negotiating or seeking legal advice before agreeing."
     if SAULLM_ENDPOINT and HF_API_TOKEN:
         try:
+            prompt = f"You are a consumer protection legal analyst. Analyze this clause and explain why it may be unfair.\n\nClause: \"{req.clause}\"\nCategory: {req.category}\n\nProvide:\n1. A plain-English explanation\n2. The specific legal basis\n3. A practical recommendation\n\nBe concise. 3-4 sentences per section."
             async with httpx.AsyncClient(timeout=30.0) as client:
+                resp = await client.post(SAULLM_ENDPOINT, json={"inputs": prompt, "parameters": {"max_new_tokens": 300, "temperature": 0.3}}, headers={"Authorization": f"Bearer {HF_API_TOKEN}"})
                 if resp.status_code == 200:
                     output = resp.json()
                     generated = output[0]["generated_text"] if isinstance(output, list) else output.get("generated_text", "")
                         legal = parts[1] if len(parts) > 1 else legal
                         recommendation = parts[2] if len(parts) > 2 else recommendation
         except Exception:
+            pass
+    return ExplainResponse(clause=req.clause, category=req.category, explanation=desc, legal_basis=legal, recommendation=recommendation)
 @app.get("/api/history")
 async def history(user: dict = Depends(require_auth), limit: int = 20, offset: int = 0):
     limit = min(limit, 100)
+    data = await supabase_query("analyses", {"user_id": f"eq.{user['id']}", "select": "*", "order": "created_at.desc", "limit": str(limit), "offset": str(offset)})
     return {"analyses": data, "limit": limit, "offset": offset}
 if __name__ == "__main__":

api/requirements.txt CHANGED Viewed

@@ -6,3 +6,5 @@ optimum[onnxruntime]>=1.24.0
 numpy>=2.0.0
 python-jose[cryptography]>=3.3.0
 httpx>=0.28.0

 numpy>=2.0.0
 python-jose[cryptography]>=3.3.0
 httpx>=0.28.0
+peft>=0.15.0
+torch>=2.5.0

web/app/api/analyze/route.ts CHANGED Viewed

@@ -14,26 +14,11 @@ export async function POST(req: NextRequest) {
       );
     }
-    // Split text into clauses
-    const clauses = text
-      .replace(/\n{2,}/g, "\n")
-      .trim()
-      .split(/(?<=[.!?])\s+(?=[A-Z0-9(])|(?:\n)(?=\d+[.)]\s|\([a-z]\)\s|•\s|-\s)/)
-      .map((c: string) => c.trim())
-      .filter((c: string) => c.length > 30);
-    if (clauses.length === 0) {
-      return NextResponse.json(
-        { error: "Could not extract clauses from the provided text." },
-        { status: 400 }
-      );
-    }
-    // Forward to backend API
     const response = await fetch(`${API_URL}/api/analyze`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ clauses, source_url }),
     });
     if (!response.ok) {

       );
     }
+    // Forward to backend API v2.0 (full text, clauses split server-side)
     const response = await fetch(`${API_URL}/api/analyze`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ text, source_url }),
     });
     if (!response.ok) {

web/app/api/compare/route.ts ADDED Viewed

	@@ -0,0 +1,33 @@

+import { NextRequest, NextResponse } from "next/server";
+const API_URL = process.env.CLAUSEGUARD_API_URL || "https://gaurv007-clauseguard-api.hf.space";
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json();
+    const { text_a, text_b } = body;
+    if (!text_a || !text_b || text_a.trim().length < 50 || text_b.trim().length < 50) {
+      return NextResponse.json(
+        { error: "Both contracts must have at least 50 characters." },
+        { status: 400 }
+      );
+    }
+    const response = await fetch(`${API_URL}/api/compare`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ text_a, text_b }),
+    });
+    if (!response.ok) {
+      throw new Error(`Backend error: ${response.status}`);
+    }
+    const result = await response.json();
+    return NextResponse.json(result);
+  } catch (error: any) {
+    console.error("Compare error:", error.message);
+    return NextResponse.json({ error: error.message || "Comparison failed" }, { status: 500 });
+  }
+}

web/app/dashboard-pages/analyze/page.tsx CHANGED Viewed

@@ -1,18 +1,38 @@
 "use client";
-import { useState, useRef, useEffect } from "react";
 import {
   ScanText, ScanLine, TriangleAlert, CircleAlert, CircleCheck, Info,
   FileDown, ChevronDown, ChevronUp, Copy, Check, Upload, FileText,
   ShieldCheck, ShieldAlert, Scale, Gavel, Ban, Globe, Eye, Stamp, FileX,
-  Lock, Sparkles as SparklesIcon, X
 } from "lucide-react";
 interface Cat { name: string; severity: string; description?: string; confidence?: number; }
 interface Clause { text: string; categories: Cat[]; }
-interface Result { risk_score: number; grade: string; total_clauses: number; flagged_count: number; results: Clause[]; model: string; latency_ms: number; }
 const SEV_CONFIG: Record<string, { icon: any; label: string; text: string; bg: string; border: string }> = {
   HIGH: { icon: TriangleAlert, label: "High", text: "text-red-600", bg: "bg-red-50", border: "border-red-200" },
   MEDIUM: { icon: CircleAlert, label: "Medium", text: "text-amber-600", bg: "bg-amber-50", border: "border-amber-200" },
   LOW: { icon: Info, label: "Low", text: "text-blue-600", bg: "bg-blue-50", border: "border-blue-200" },
@@ -20,16 +40,42 @@ const SEV_CONFIG: Record<string, { icon: any; label: string; text: string; bg: s
 const GRADE_STYLE: Record<string, string> = {
   A: "bg-emerald-50 text-emerald-700 border-emerald-200",
-  B: "bg-emerald-50 text-emerald-700 border-emerald-200",
   C: "bg-amber-50 text-amber-700 border-amber-200",
-  D: "bg-red-50 text-red-700 border-red-200",
   F: "bg-red-50 text-red-700 border-red-200",
 };
 const CATEGORY_ICONS: Record<string, any> = {
   "Arbitration": Scale, "Limitation of liability": ShieldAlert, "Unilateral termination": Ban,
   "Unilateral change": FileX, "Content removal": Eye, "Jurisdiction": Globe,
-  "Choice of law": Gavel, "Contract by using": Stamp,
 };
 const EXAMPLE = `By using the Spotify Service, you agree to be bound by these Terms of Use.
@@ -48,11 +94,12 @@ Any dispute shall be finally settled by arbitration in New York County.`;
 export default function AnalyzePage() {
   const [text, setText] = useState("");
-  const [results, setResults] = useState<Result | null>(null);
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState("");
   const [expandedIdx, setExpandedIdx] = useState<number | null>(null);
   const [filter, setFilter] = useState<string>("all");
   const [copied, setCopied] = useState(false);
   const [scanCount, setScanCount] = useState(0);
   const [userPlan, setUserPlan] = useState("free");
@@ -64,7 +111,6 @@ export default function AnalyzePage() {
   async function handleAnalyze() {
     if (!text || text.trim().length < 50) { setError("Enter at least 50 characters."); return; }
     if (!canScan) { setShowUpgrade(true); return; }
     setLoading(true); setError(""); setResults(null); setExpandedIdx(null);
@@ -81,27 +127,17 @@ export default function AnalyzePage() {
   async function handleFileUpload(e: React.ChangeEvent<HTMLInputElement>) {
     const file = e.target.files?.[0];
     if (!file) return;
     if (userPlan === "free") { setShowUpgrade(true); return; }
-    setLoading(true);
-    setError("");
     try {
       const formData = new FormData();
       formData.append("file", file);
       const res = await fetch("/api/parse-upload", { method: "POST", body: formData });
-      if (!res.ok) {
-        const err = await res.json();
-        throw new Error(err.error || "Failed to parse file");
-      }
       const { text: extractedText } = await res.json();
       setText(extractedText);
-    } catch (e: any) {
-      setError(e.message || "Could not read file.");
-    }
     setLoading(false);
     if (fileInputRef.current) fileInputRef.current.value = "";
   }
@@ -119,7 +155,7 @@ export default function AnalyzePage() {
   function handleCopy() {
     if (!results) return;
-    const summary = `ClauseGuard Report\nRisk: ${results.risk_score}/100 (Grade ${results.grade})\n${results.flagged_count} of ${results.total_clauses} clauses flagged\n\n` +
       results.results.filter(r => r.categories.length > 0).map((r, i) =>
         `${i+1}. [${r.categories.map(c => c.name).join(", ")}] ${r.text.slice(0, 100)}...`
       ).join("\n");
@@ -130,82 +166,87 @@ export default function AnalyzePage() {
   const flagged = results?.results.filter(r => r.categories.length > 0) || [];
   const filtered = filter === "all" ? flagged : flagged.filter(r => r.categories.some(c => c.severity === filter));
-  const sevCounts = { HIGH: 0, MEDIUM: 0, LOW: 0 };
   flagged.forEach(r => r.categories.forEach(c => { if (sevCounts[c.severity as keyof typeof sevCounts] !== undefined) sevCounts[c.severity as keyof typeof sevCounts]++; }));
   return (
     <div className="min-h-screen bg-white">
-      {/* Upgrade modal */}
       {showUpgrade && (
         <div className="fixed inset-0 z-50 flex items-center justify-center bg-black/40">
           <div className="bg-white rounded-2xl p-6 max-w-sm mx-4 shadow-xl">
             <div className="flex justify-between items-start">
-              <div className="w-10 h-10 rounded-xl bg-amber-50 flex items-center justify-center">
-                <Lock className="w-5 h-5 text-amber-600" />
-              </div>
               <button onClick={() => setShowUpgrade(false)} className="p-1 hover:bg-zinc-100 rounded-md"><X className="w-4 h-4 text-zinc-400" /></button>
             </div>
-            <h3 className="mt-4 text-lg font-semibold">
-              {userPlan === "free" && scanCount >= FREE_LIMIT ? "Free limit reached" : "Pro feature"}
-            </h3>
             <p className="mt-1.5 text-sm text-zinc-500 leading-relaxed">
               {userPlan === "free" && scanCount >= FREE_LIMIT
-                ? `You have used all ${FREE_LIMIT} free scans this month. Upgrade to Pro for unlimited scans, file uploads, and AI explanations.`
                 : "File upload is available on the Pro plan. Upgrade to scan contracts and leases directly."}
             </p>
             <div className="mt-5 flex gap-2">
-              <a href="/#pricing" className="flex-1 bg-zinc-900 text-white py-2.5 rounded-lg text-sm font-medium text-center hover:bg-zinc-800 transition-colors">
-                View plans
-              </a>
-              <button onClick={() => setShowUpgrade(false)} className="flex-1 border border-zinc-200 py-2.5 rounded-lg text-sm font-medium hover:bg-zinc-50 transition-colors">
-                Not now
-              </button>
             </div>
           </div>
         </div>
       )}
-      <div className="max-w-6xl mx-auto px-5 py-10">
         <div className="mb-8 flex items-start justify-between">
           <div>
             <h1 className="text-2xl font-semibold tracking-tight flex items-center gap-2">
               <ScanText className="w-6 h-6 text-zinc-400" />
               Scan a document
             </h1>
-            <p className="mt-1 text-sm text-zinc-500">Paste text or upload a file (.pdf, .docx, .txt).</p>
           </div>
           {userPlan === "free" && (
-            <span className="text-xs text-zinc-400 border border-zinc-200 px-2.5 py-1 rounded-md">
-              {scanCount}/{FREE_LIMIT} free scans
-            </span>
           )}
         </div>
         <div className="grid lg:grid-cols-5 gap-6">
-          {/* Input — 2 cols */}
           <div className="lg:col-span-2">
             <textarea value={text} onChange={(e) => setText(e.target.value)}
-              placeholder="Paste your document text here..."
               className="w-full h-[380px] p-4 border border-zinc-200 rounded-xl text-sm leading-relaxed resize-none focus:outline-none focus:ring-2 focus:ring-zinc-900/10 focus:border-zinc-300 placeholder:text-zinc-300 font-mono" />
             <div className="mt-3 flex gap-2">
               <button onClick={handleAnalyze} disabled={loading}
                 className="flex-1 inline-flex items-center justify-center gap-2 bg-zinc-900 text-white py-2.5 rounded-lg text-sm font-medium hover:bg-zinc-800 disabled:opacity-40 transition-colors">
-                {loading ? <><ScanLine className="w-4 h-4 animate-pulse" /> Scanning...</> : <><ScanText className="w-4 h-4" /> Scan</>}
-              </button>
-              <button onClick={() => setText(EXAMPLE)}
-                className="px-3 border border-zinc-200 rounded-lg text-sm text-zinc-500 hover:bg-zinc-50 transition-colors">
-                Example
               </button>
               <input ref={fileInputRef} type="file" accept=".txt,.md,.pdf,.docx" className="hidden" onChange={handleFileUpload} />
-              <button onClick={() => fileInputRef.current?.click()}
-                className="px-3 border border-zinc-200 rounded-lg text-zinc-500 hover:bg-zinc-50 transition-colors" title="Upload file">
-                <Upload className="w-4 h-4" />
-              </button>
             </div>
             {error && <p className="mt-2 text-sm text-red-600 flex items-center gap-1.5"><TriangleAlert className="w-3.5 h-3.5" />{error}</p>}
           </div>
-          {/* Results — 3 cols */}
           <div className="lg:col-span-3">
             {results ? (
               <div className="space-y-4">
@@ -228,32 +269,27 @@ export default function AnalyzePage() {
                     </span>
                   </div>
                   <div className="mt-4 flex items-center gap-4 text-xs text-zinc-400">
-                    <span>{results.total_clauses} clauses</span>
-                    <span className="w-px h-3 bg-zinc-200" />
-                    <span>{results.flagged_count} flagged</span>
-                    <span className="w-px h-3 bg-zinc-200" />
-                    <span>{results.latency_ms}ms</span>
-                    <span className="w-px h-3 bg-zinc-200" />
-                    <span className="flex items-center gap-1">
-                      {results.model === "ml" && <SparklesIcon className="w-3 h-3" />}
-                      {results.model === "ml" ? "Legal-BERT" : "Pattern matching"}
-                    </span>
                   </div>
                 </div>
-                {/* Actions bar */}
                 <div className="flex items-center justify-between">
                   <div className="flex gap-1">
                     {[
                       { key: "all", label: "All", count: flagged.length },
                       { key: "HIGH", label: "High", count: sevCounts.HIGH },
                       { key: "MEDIUM", label: "Medium", count: sevCounts.MEDIUM },
                       { key: "LOW", label: "Low", count: sevCounts.LOW },
                     ].map((f) => (
                       <button key={f.key} onClick={() => setFilter(f.key)}
-                        className={`px-3 py-1.5 text-xs font-medium rounded-md transition-colors ${
-                          filter === f.key ? "bg-zinc-900 text-white" : "text-zinc-500 hover:bg-zinc-100"
-                        }`}>
                         {f.label} {f.count > 0 && <span className="ml-1 opacity-60">{f.count}</span>}
                       </button>
                     ))}
@@ -262,74 +298,223 @@ export default function AnalyzePage() {
                     <button onClick={handleCopy} className="p-2 rounded-md hover:bg-zinc-100 text-zinc-400 hover:text-zinc-600 transition-colors" title="Copy summary">
                       {copied ? <Check className="w-4 h-4 text-emerald-500" /> : <Copy className="w-4 h-4" />}
                     </button>
-                    <button onClick={handleDownloadPDF} className="p-2 rounded-md hover:bg-zinc-100 text-zinc-400 hover:text-zinc-600 transition-colors" title="Download PDF">
-                      <FileDown className="w-4 h-4" />
-                    </button>
                   </div>
                 </div>
-                {/* Clause list */}
-                <div className="space-y-2 max-h-[380px] overflow-y-auto pr-1">
-                  {filtered.length === 0 ? (
-                    <div className="border border-dashed border-zinc-200 rounded-xl p-10 text-center">
-                      <CircleCheck className="w-8 h-8 text-emerald-400 mx-auto mb-2" />
-                      <p className="text-sm text-zinc-500">{filter === "all" ? "No unfair clauses found." : "No clauses at this severity."}</p>
                     </div>
-                  ) : filtered.map((clause, i) => {
-                    const maxSev = clause.categories.reduce((m, c) => {
-                      const order: Record<string, number> = { HIGH: 3, MEDIUM: 2, LOW: 1 };
-                      return (order[c.severity] || 0) > (order[m] || 0) ? c.severity : m;
-                    }, "LOW");
-                    const conf = SEV_CONFIG[maxSev] || SEV_CONFIG.MEDIUM;
-                    const isExpanded = expandedIdx === i;
-                    const CatIcon = CATEGORY_ICONS[clause.categories[0]?.name] || TriangleAlert;
-                    return (
-                      <div key={i} className={`border rounded-xl overflow-hidden transition-all ${conf.border} ${isExpanded ? "shadow-sm" : ""}`}>
-                        <button onClick={() => setExpandedIdx(isExpanded ? null : i)}
-                          className="w-full text-left p-4 flex items-start gap-3 hover:bg-zinc-50/50 transition-colors">
-                          <div className={`w-8 h-8 rounded-lg flex items-center justify-center shrink-0 ${conf.bg}`}>
-                            <CatIcon className={`w-4 h-4 ${conf.text}`} />
                           </div>
-                          <div className="flex-1 min-w-0">
-                            <div className="flex items-center gap-2 flex-wrap">
-                              {clause.categories.map((cat, j) => {
-                                const s = SEV_CONFIG[cat.severity] || SEV_CONFIG.MEDIUM;
-                                return (
-                                  <span key={j} className={`text-[11px] font-medium px-2 py-0.5 rounded border ${s.bg} ${s.text} ${s.border}`}>
-                                    {cat.name}{cat.confidence ? ` ${Math.round(cat.confidence * 100)}%` : ""}
-                                  </span>
-                                );
-                              })}
                             </div>
-                            <p className="mt-1.5 text-sm text-zinc-600 leading-relaxed line-clamp-2">{clause.text}</p>
                           </div>
-                          <div className="shrink-0 mt-1">
-                            {isExpanded ? <ChevronUp className="w-4 h-4 text-zinc-400" /> : <ChevronDown className="w-4 h-4 text-zinc-400" />}
                           </div>
-                        </button>
-                        {isExpanded && (
-                          <div className="px-4 pb-4 pt-0 border-t border-zinc-100">
-                            <p className="text-sm text-zinc-700 leading-relaxed mt-3 font-mono bg-zinc-50 rounded-lg p-3">{clause.text}</p>
-                            {clause.categories.map((cat, j) => (
-                              <div key={j} className="mt-3 flex items-start gap-2">
-                                <TriangleAlert className={`w-3.5 h-3.5 mt-0.5 shrink-0 ${(SEV_CONFIG[cat.severity] || SEV_CONFIG.MEDIUM).text}`} />
-                                <p className="text-[13px] text-zinc-500 leading-relaxed">
-                                  <span className="font-medium text-zinc-700">{cat.name}:</span> {cat.description || "This clause may be unfair under consumer protection law."}
-                                </p>
                               </div>
-                            ))}
                           </div>
-                        )}
-                      </div>
-                    );
-                  })}
                 </div>
               </div>
             ) : (
               <div className="border border-dashed border-zinc-200 rounded-xl h-[420px] flex flex-col items-center justify-center">
                 <ScanText className="w-10 h-10 text-zinc-200 mb-3" />
-                <p className="text-sm text-zinc-300">Paste text and scan to see results</p>
               </div>
             )}
           </div>

 "use client";
+import { useState, useRef } from "react";
 import {
   ScanText, ScanLine, TriangleAlert, CircleAlert, CircleCheck, Info,
   FileDown, ChevronDown, ChevronUp, Copy, Check, Upload, FileText,
   ShieldCheck, ShieldAlert, Scale, Gavel, Ban, Globe, Eye, Stamp, FileX,
+  Lock, Sparkles as SparklesIcon, X, Layers, Landmark, Briefcase,
+  AlertTriangle, Tag, BookOpen, ClipboardList, FileCompare, DollarSign,
+  Calendar, Building, MapPin, Hash
 } from "lucide-react";
 interface Cat { name: string; severity: string; description?: string; confidence?: number; }
 interface Clause { text: string; categories: Cat[]; }
+interface Entity { text: string; type: string; }
+interface Contradiction { type: string; explanation: string; severity: string; }
+interface Obligation { type: string; party: string; description: string; deadline: string; }
+interface ComplianceCheck { requirement: string; description: string; severity: string; status: string; matched_keywords: string[]; }
+interface ComplianceReg { description: string; compliance_rate: number; checks: ComplianceCheck[]; overall_status: string; }
+interface AnalysisResult {
+  risk_score: number;
+  grade: string;
+  total_clauses: number;
+  flagged_count: number;
+  results: Clause[];
+  entities: Entity[];
+  contradictions: Contradiction[];
+  obligations: Obligation[];
+  compliance: Record<string, ComplianceReg>;
+  model: string;
+  latency_ms: number;
+}
 const SEV_CONFIG: Record<string, { icon: any; label: string; text: string; bg: string; border: string }> = {
+  CRITICAL: { icon: AlertTriangle, label: "Critical", text: "text-red-700", bg: "bg-red-50", border: "border-red-300" },
   HIGH: { icon: TriangleAlert, label: "High", text: "text-red-600", bg: "bg-red-50", border: "border-red-200" },
   MEDIUM: { icon: CircleAlert, label: "Medium", text: "text-amber-600", bg: "bg-amber-50", border: "border-amber-200" },
   LOW: { icon: Info, label: "Low", text: "text-blue-600", bg: "bg-blue-50", border: "border-blue-200" },
 const GRADE_STYLE: Record<string, string> = {
   A: "bg-emerald-50 text-emerald-700 border-emerald-200",
+  B: "bg-emerald-50 text-emerald-600 border-emerald-200",
   C: "bg-amber-50 text-amber-700 border-amber-200",
+  D: "bg-orange-50 text-orange-700 border-orange-200",
   F: "bg-red-50 text-red-700 border-red-200",
 };
 const CATEGORY_ICONS: Record<string, any> = {
   "Arbitration": Scale, "Limitation of liability": ShieldAlert, "Unilateral termination": Ban,
   "Unilateral change": FileX, "Content removal": Eye, "Jurisdiction": Globe,
+  "Choice of law": Gavel, "Contract by using": Stamp, "Uncapped Liability": AlertTriangle,
+  "IP Ownership Assignment": Lock, "Non-Compete": Ban, "Governing Law": Gavel,
+  "Termination for Convenience": Ban, "Indemnification": ShieldCheck, "Confidentiality": Lock,
+};
+const ENTITY_COLORS: Record<string, { bg: string; text: string; border: string; icon: any }> = {
+  DATE: { bg: "bg-blue-50", text: "text-blue-700", border: "border-blue-200", icon: Calendar },
+  DATE_REF: { bg: "bg-blue-50", text: "text-blue-600", border: "border-blue-200", icon: Calendar },
+  MONEY: { bg: "bg-emerald-50", text: "text-emerald-700", border: "border-emerald-200", icon: DollarSign },
+  PARTY: { bg: "bg-purple-50", text: "text-purple-700", border: "border-purple-200", icon: Building },
+  PARTY_ROLE: { bg: "bg-purple-50", text: "text-purple-600", border: "border-purple-200", icon: Briefcase },
+  JURISDICTION: { bg: "bg-amber-50", text: "text-amber-700", border: "border-amber-200", icon: MapPin },
+  DEFINED_TERM: { bg: "bg-pink-50", text: "text-pink-700", border: "border-pink-200", icon: Hash },
+};
+const OBLIGATION_COLORS: Record<string, { bg: string; text: string; icon: any }> = {
+  monetary: { bg: "bg-emerald-50", text: "text-emerald-700", icon: DollarSign },
+  compliance: { bg: "bg-amber-50", text: "text-amber-700", icon: ShieldCheck },
+  reporting: { bg: "bg-blue-50", text: "text-blue-700", icon: ClipboardList },
+  delivery: { bg: "bg-purple-50", text: "text-purple-700", icon: FileText },
+  termination: { bg: "bg-red-50", text: "text-red-700", icon: Ban },
+};
+const COMPLIANCE_STATUS: Record<string, { bg: string; text: string }> = {
+  COMPLIANT: { bg: "bg-emerald-50", text: "text-emerald-700" },
+  PARTIAL: { bg: "bg-amber-50", text: "text-amber-700" },
+  "NON-COMPLIANT": { bg: "bg-red-50", text: "text-red-700" },
 };
 const EXAMPLE = `By using the Spotify Service, you agree to be bound by these Terms of Use.
 export default function AnalyzePage() {
   const [text, setText] = useState("");
+  const [results, setResults] = useState<AnalysisResult | null>(null);
   const [loading, setLoading] = useState(false);
   const [error, setError] = useState("");
   const [expandedIdx, setExpandedIdx] = useState<number | null>(null);
   const [filter, setFilter] = useState<string>("all");
+  const [activeTab, setActiveTab] = useState<string>("clauses");
   const [copied, setCopied] = useState(false);
   const [scanCount, setScanCount] = useState(0);
   const [userPlan, setUserPlan] = useState("free");
   async function handleAnalyze() {
     if (!text || text.trim().length < 50) { setError("Enter at least 50 characters."); return; }
     if (!canScan) { setShowUpgrade(true); return; }
     setLoading(true); setError(""); setResults(null); setExpandedIdx(null);
   async function handleFileUpload(e: React.ChangeEvent<HTMLInputElement>) {
     const file = e.target.files?.[0];
     if (!file) return;
     if (userPlan === "free") { setShowUpgrade(true); return; }
+    setLoading(true); setError("");
     try {
       const formData = new FormData();
       formData.append("file", file);
       const res = await fetch("/api/parse-upload", { method: "POST", body: formData });
+      if (!res.ok) throw new Error((await res.json()).error || "Failed to parse file");
       const { text: extractedText } = await res.json();
       setText(extractedText);
+    } catch (e: any) { setError(e.message || "Could not read file."); }
     setLoading(false);
     if (fileInputRef.current) fileInputRef.current.value = "";
   }
   function handleCopy() {
     if (!results) return;
+    const summary = `ClauseGuard Report\nRisk: ${results.risk_score}/100 (Grade ${results.grade})\n${results.flagged_count} of ${results.total_clauses} clauses flagged\nEntities: ${results.entities.length} found\nContradictions: ${results.contradictions.length} detected\n\n` +
       results.results.filter(r => r.categories.length > 0).map((r, i) =>
         `${i+1}. [${r.categories.map(c => c.name).join(", ")}] ${r.text.slice(0, 100)}...`
       ).join("\n");
   const flagged = results?.results.filter(r => r.categories.length > 0) || [];
   const filtered = filter === "all" ? flagged : flagged.filter(r => r.categories.some(c => c.severity === filter));
+  const sevCounts = { CRITICAL: 0, HIGH: 0, MEDIUM: 0, LOW: 0 };
   flagged.forEach(r => r.categories.forEach(c => { if (sevCounts[c.severity as keyof typeof sevCounts] !== undefined) sevCounts[c.severity as keyof typeof sevCounts]++; }));
+  // Group entities by type
+  const entityGroups: Record<string, string[]> = {};
+  results?.entities.forEach(e => {
+    if (!entityGroups[e.type]) entityGroups[e.type] = [];
+    if (!entityGroups[e.type].includes(e.text)) entityGroups[e.type].push(e.text);
+  });
+  // Group obligations by type
+  const obligationGroups: Record<string, Obligation[]> = {};
+  results?.obligations.forEach(o => {
+    if (!obligationGroups[o.type]) obligationGroups[o.type] = [];
+    obligationGroups[o.type].push(o);
+  });
+  const tabs = [
+    { key: "clauses", label: "Clauses", icon: Layers },
+    { key: "entities", label: "Entities", icon: Tag },
+    { key: "contradictions", label: "Contradictions", icon: AlertTriangle },
+    { key: "obligations", label: "Obligations", icon: ClipboardList },
+    { key: "compliance", label: "Compliance", icon: ShieldCheck },
+  ];
   return (
     <div className="min-h-screen bg-white">
       {showUpgrade && (
         <div className="fixed inset-0 z-50 flex items-center justify-center bg-black/40">
           <div className="bg-white rounded-2xl p-6 max-w-sm mx-4 shadow-xl">
             <div className="flex justify-between items-start">
+              <div className="w-10 h-10 rounded-xl bg-amber-50 flex items-center justify-center"><Lock className="w-5 h-5 text-amber-600" /></div>
               <button onClick={() => setShowUpgrade(false)} className="p-1 hover:bg-zinc-100 rounded-md"><X className="w-4 h-4 text-zinc-400" /></button>
             </div>
+            <h3 className="mt-4 text-lg font-semibold">{userPlan === "free" && scanCount >= FREE_LIMIT ? "Free limit reached" : "Pro feature"}</h3>
             <p className="mt-1.5 text-sm text-zinc-500 leading-relaxed">
               {userPlan === "free" && scanCount >= FREE_LIMIT
+                ? `You have used all ${FREE_LIMIT} free scans. Upgrade to Pro for unlimited scans, file uploads, and full analysis.`
                 : "File upload is available on the Pro plan. Upgrade to scan contracts and leases directly."}
             </p>
             <div className="mt-5 flex gap-2">
+              <a href="/#pricing" className="flex-1 bg-zinc-900 text-white py-2.5 rounded-lg text-sm font-medium text-center hover:bg-zinc-800 transition-colors">View plans</a>
+              <button onClick={() => setShowUpgrade(false)} className="flex-1 border border-zinc-200 py-2.5 rounded-lg text-sm font-medium hover:bg-zinc-50 transition-colors">Not now</button>
             </div>
           </div>
         </div>
       )}
+      <div className="max-w-7xl mx-auto px-5 py-10">
         <div className="mb-8 flex items-start justify-between">
           <div>
             <h1 className="text-2xl font-semibold tracking-tight flex items-center gap-2">
               <ScanText className="w-6 h-6 text-zinc-400" />
               Scan a document
             </h1>
+            <p className="mt-1 text-sm text-zinc-500">Paste text or upload a file (.pdf, .docx, .txt). Get 41-category clause detection, risk scoring, NER, compliance, and more.</p>
           </div>
           {userPlan === "free" && (
+            <span className="text-xs text-zinc-400 border border-zinc-200 px-2.5 py-1 rounded-md">{scanCount}/{FREE_LIMIT} free scans</span>
           )}
         </div>
         <div className="grid lg:grid-cols-5 gap-6">
+          {/* Input */}
           <div className="lg:col-span-2">
             <textarea value={text} onChange={(e) => setText(e.target.value)}
+              placeholder="Paste your contract or terms text here..."
               className="w-full h-[380px] p-4 border border-zinc-200 rounded-xl text-sm leading-relaxed resize-none focus:outline-none focus:ring-2 focus:ring-zinc-900/10 focus:border-zinc-300 placeholder:text-zinc-300 font-mono" />
             <div className="mt-3 flex gap-2">
               <button onClick={handleAnalyze} disabled={loading}
                 className="flex-1 inline-flex items-center justify-center gap-2 bg-zinc-900 text-white py-2.5 rounded-lg text-sm font-medium hover:bg-zinc-800 disabled:opacity-40 transition-colors">
+                {loading ? <><ScanLine className="w-4 h-4 animate-pulse" /> Analyzing...</> : <><ScanText className="w-4 h-4" /> Analyze</>}
               </button>
+              <button onClick={() => setText(EXAMPLE)} className="px-3 border border-zinc-200 rounded-lg text-sm text-zinc-500 hover:bg-zinc-50 transition-colors">Example</button>
               <input ref={fileInputRef} type="file" accept=".txt,.md,.pdf,.docx" className="hidden" onChange={handleFileUpload} />
+              <button onClick={() => fileInputRef.current?.click()} className="px-3 border border-zinc-200 rounded-lg text-zinc-500 hover:bg-zinc-50 transition-colors" title="Upload file"><Upload className="w-4 h-4" /></button>
             </div>
             {error && <p className="mt-2 text-sm text-red-600 flex items-center gap-1.5"><TriangleAlert className="w-3.5 h-3.5" />{error}</p>}
           </div>
+          {/* Results */}
           <div className="lg:col-span-3">
             {results ? (
               <div className="space-y-4">
                     </span>
                   </div>
                   <div className="mt-4 flex items-center gap-4 text-xs text-zinc-400">
+                    <span>{results.total_clauses} clauses</span><span className="w-px h-3 bg-zinc-200" />
+                    <span>{results.flagged_count} flagged</span><span className="w-px h-3 bg-zinc-200" />
+                    <span>{results.entities.length} entities</span><span className="w-px h-3 bg-zinc-200" />
+                    <span>{results.contradictions.length} issues</span><span className="w-px h-3 bg-zinc-200" />
+                    <span>{results.latency_ms}ms</span><span className="w-px h-3 bg-zinc-200" />
+                    <span className="flex items-center gap-1">{results.model !== "regex" && <SparklesIcon className="w-3 h-3" />}{results.model !== "regex" ? "Legal-BERT v2" : "Pattern fallback"}</span>
                   </div>
                 </div>
+                {/* Filter + Actions */}
                 <div className="flex items-center justify-between">
                   <div className="flex gap-1">
                     {[
                       { key: "all", label: "All", count: flagged.length },
+                      { key: "CRITICAL", label: "Critical", count: sevCounts.CRITICAL },
                       { key: "HIGH", label: "High", count: sevCounts.HIGH },
                       { key: "MEDIUM", label: "Medium", count: sevCounts.MEDIUM },
                       { key: "LOW", label: "Low", count: sevCounts.LOW },
                     ].map((f) => (
                       <button key={f.key} onClick={() => setFilter(f.key)}
+                        className={`px-3 py-1.5 text-xs font-medium rounded-md transition-colors ${filter === f.key ? "bg-zinc-900 text-white" : "text-zinc-500 hover:bg-zinc-100"}`}>
                         {f.label} {f.count > 0 && <span className="ml-1 opacity-60">{f.count}</span>}
                       </button>
                     ))}
                     <button onClick={handleCopy} className="p-2 rounded-md hover:bg-zinc-100 text-zinc-400 hover:text-zinc-600 transition-colors" title="Copy summary">
                       {copied ? <Check className="w-4 h-4 text-emerald-500" /> : <Copy className="w-4 h-4" />}
                     </button>
+                    <button onClick={handleDownloadPDF} className="p-2 rounded-md hover:bg-zinc-100 text-zinc-400 hover:text-zinc-600 transition-colors" title="Download PDF"><FileDown className="w-4 h-4" /></button>
                   </div>
                 </div>
+                {/* Tabs */}
+                <div className="border-b border-zinc-200">
+                  <div className="flex gap-1">
+                    {tabs.map((t) => (
+                      <button key={t.key} onClick={() => setActiveTab(t.key)}
+                        className={`flex items-center gap-1.5 px-3 py-2 text-sm font-medium border-b-2 transition-colors ${
+                          activeTab === t.key ? "border-zinc-900 text-zinc-900" : "border-transparent text-zinc-400 hover:text-zinc-600"
+                        }`}>
+                        <t.icon className="w-4 h-4" />{t.label}
+                      </button>
+                    ))}
+                  </div>
+                </div>
+                {/* Tab Content */}
+                <div className="max-h-[420px] overflow-y-auto pr-1">
+                  {/* Clauses Tab */}
+                  {activeTab === "clauses" && (
+                    <div className="space-y-2">
+                      {filtered.length === 0 ? (
+                        <div className="border border-dashed border-zinc-200 rounded-xl p-10 text-center">
+                          <CircleCheck className="w-8 h-8 text-emerald-400 mx-auto mb-2" />
+                          <p className="text-sm text-zinc-500">{filter === "all" ? "No flagged clauses found." : "No clauses at this severity."}</p>
+                        </div>
+                      ) : filtered.map((clause, i) => {
+                        const maxSev = clause.categories.reduce((m, c) => {
+                          const order: Record<string, number> = { CRITICAL: 4, HIGH: 3, MEDIUM: 2, LOW: 1 };
+                          return (order[c.severity] || 0) > (order[m] || 0) ? c.severity : m;
+                        }, "LOW");
+                        const conf = SEV_CONFIG[maxSev] || SEV_CONFIG.MEDIUM;
+                        const isExpanded = expandedIdx === i;
+                        const CatIcon = CATEGORY_ICONS[clause.categories[0]?.name] || Layers;
+                        return (
+                          <div key={i} className={`border rounded-xl overflow-hidden transition-all ${conf.border} ${isExpanded ? "shadow-sm" : ""}`}>
+                            <button onClick={() => setExpandedIdx(isExpanded ? null : i)} className="w-full text-left p-4 flex items-start gap-3 hover:bg-zinc-50/50 transition-colors">
+                              <div className={`w-8 h-8 rounded-lg flex items-center justify-center shrink-0 ${conf.bg}`}>
+                                <CatIcon className={`w-4 h-4 ${conf.text}`} />
+                              </div>
+                              <div className="flex-1 min-w-0">
+                                <div className="flex items-center gap-2 flex-wrap">
+                                  {clause.categories.map((cat, j) => {
+                                    const s = SEV_CONFIG[cat.severity] || SEV_CONFIG.MEDIUM;
+                                    return (
+                                      <span key={j} className={`text-[11px] font-medium px-2 py-0.5 rounded border ${s.bg} ${s.text} ${s.border}`}>
+                                        {cat.name}{cat.confidence ? ` ${Math.round(cat.confidence * 100)}%` : ""}
+                                      </span>
+                                    );
+                                  })}
+                                </div>
+                                <p className="mt-1.5 text-sm text-zinc-600 leading-relaxed line-clamp-2">{clause.text}</p>
+                              </div>
+                              <div className="shrink-0 mt-1">{isExpanded ? <ChevronUp className="w-4 h-4 text-zinc-400" /> : <ChevronDown className="w-4 h-4 text-zinc-400" />}</div>
+                            </button>
+                            {isExpanded && (
+                              <div className="px-4 pb-4 pt-0 border-t border-zinc-100">
+                                <p className="text-sm text-zinc-700 leading-relaxed mt-3 font-mono bg-zinc-50 rounded-lg p-3">{clause.text}</p>
+                                {clause.categories.map((cat, j) => (
+                                  <div key={j} className="mt-3 flex items-start gap-2">
+                                    <TriangleAlert className={`w-3.5 h-3.5 mt-0.5 shrink-0 ${(SEV_CONFIG[cat.severity] || SEV_CONFIG.MEDIUM).text}`} />
+                                    <p className="text-[13px] text-zinc-500 leading-relaxed">
+                                      <span className="font-medium text-zinc-700">{cat.name}:</span> {cat.description || "This clause may contain risks. Review carefully."}
+                                    </p>
+                                  </div>
+                                ))}
+                              </div>
+                            )}
+                          </div>
+                        );
+                      })}
                     </div>
+                  )}
+                  {/* Entities Tab */}
+                  {activeTab === "entities" && (
+                    <div className="space-y-4">
+                      {Object.keys(entityGroups).length === 0 ? (
+                        <div className="border border-dashed border-zinc-200 rounded-xl p-10 text-center">
+                          <Tag className="w-8 h-8 text-zinc-300 mx-auto mb-2" />
+                          <p className="text-sm text-zinc-500">No entities detected.</p>
+                        </div>
+                      ) : Object.entries(entityGroups).map(([type, items]) => {
+                        const cfg = ENTITY_COLORS[type] || { bg: "bg-zinc-50", text: "text-zinc-700", border: "border-zinc-200", icon: Tag };
+                        const Icon = cfg.icon;
+                        return (
+                          <div key={type}>
+                            <div className="flex items-center gap-2 mb-2">
+                              <Icon className={`w-4 h-4 ${cfg.text}`} />
+                              <span className="text-sm font-medium text-zinc-700">{type.replace("_", " ")}</span>
+                              <span className="text-xs text-zinc-400">({items.length})</span>
+                            </div>
+                            <div className="flex flex-wrap gap-2">
+                              {items.slice(0, 20).map((item, i) => (
+                                <span key={i} className={`inline-flex items-center px-2.5 py-1 rounded-md text-xs font-medium ${cfg.bg} ${cfg.text} border ${cfg.border}`}>
+                                  {item}
+                                </span>
+                              ))}
+                            </div>
                           </div>
+                        );
+                      })}
+                    </div>
+                  )}
+                  {/* Contradictions Tab */}
+                  {activeTab === "contradictions" && (
+                    <div className="space-y-2">
+                      {results.contradictions.length === 0 ? (
+                        <div className="border border-dashed border-zinc-200 rounded-xl p-10 text-center">
+                          <CircleCheck className="w-8 h-8 text-emerald-400 mx-auto mb-2" />
+                          <p className="text-sm text-zinc-500">No contradictions or missing clauses detected.</p>
+                        </div>
+                      ) : results.contradictions.map((c, i) => {
+                        const conf = SEV_CONFIG[c.severity] || SEV_CONFIG.MEDIUM;
+                        return (
+                          <div key={i} className={`border rounded-xl p-4 ${conf.border} ${conf.bg}`}>
+                            <div className="flex items-center gap-2 mb-2">
+                              <conf.icon className={`w-4 h-4 ${conf.text}`} />
+                              <span className={`text-xs font-semibold uppercase ${conf.text}`}>{c.type}</span>
                             </div>
+                            <p className="text-sm text-zinc-700">{c.explanation}</p>
                           </div>
+                        );
+                      })}
+                    </div>
+                  )}
+                  {/* Obligations Tab */}
+                  {activeTab === "obligations" && (
+                    <div className="space-y-4">
+                      {Object.keys(obligationGroups).length === 0 ? (
+                        <div className="border border-dashed border-zinc-200 rounded-xl p-10 text-center">
+                          <ClipboardList className="w-8 h-8 text-zinc-300 mx-auto mb-2" />
+                          <p className="text-sm text-zinc-500">No obligations detected.</p>
+                        </div>
+                      ) : Object.entries(obligationGroups).map(([type, items]) => {
+                        const cfg = OBLIGATION_COLORS[type] || { bg: "bg-zinc-50", text: "text-zinc-700", icon: ClipboardList };
+                        const Icon = cfg.icon;
+                        return (
+                          <div key={type}>
+                            <div className="flex items-center gap-2 mb-2">
+                              <Icon className={`w-4 h-4 ${cfg.text}`} />
+                              <span className="text-sm font-medium capitalize text-zinc-700">{type} Obligations</span>
+                              <span className="text-xs text-zinc-400">({items.length})</span>
+                            </div>
+                            <div className="space-y-2">
+                              {items.map((o, i) => (
+                                <div key={i} className="border border-zinc-200 rounded-lg p-3">
+                                  <div className="flex items-center justify-between mb-1">
+                                    <span className="text-xs font-medium text-zinc-600">{o.party}</span>
+                                    <span className="text-[11px] text-zinc-400 bg-zinc-100 px-2 py-0.5 rounded">{o.deadline}</span>
+                                  </div>
+                                  <p className="text-sm text-zinc-600">{o.description}</p>
+                                </div>
+                              ))}
+                            </div>
                           </div>
+                        );
+                      })}
+                    </div>
+                  )}
+                  {/* Compliance Tab */}
+                  {activeTab === "compliance" && (
+                    <div className="space-y-4">
+                      {Object.keys(results.compliance).length === 0 ? (
+                        <div className="border border-dashed border-zinc-200 rounded-xl p-10 text-center">
+                          <ShieldCheck className="w-8 h-8 text-zinc-300 mx-auto mb-2" />
+                          <p className="text-sm text-zinc-500">No compliance data available.</p>
+                        </div>
+                      ) : Object.entries(results.compliance).map(([regName, reg]) => {
+                        const status = COMPLIANCE_STATUS[reg.overall_status] || COMPLIANCE_STATUS.PARTIAL;
+                        return (
+                          <div key={regName} className="border border-zinc-200 rounded-xl overflow-hidden">
+                            <div className="flex items-center justify-between p-4 border-b border-zinc-100 bg-zinc-50/50">
+                              <div>
+                                <span className="text-sm font-semibold text-zinc-900">{regName}</span>
+                                <p className="text-[11px] text-zinc-500 mt-0.5">{reg.description}</p>
+                              </div>
+                              <div className="text-right">
+                                <span className={`text-lg font-bold ${status.text}`}>{reg.compliance_rate}%</span>
+                                <span className={`text-[11px] font-medium block ${status.text}`}>{reg.overall_status}</span>
                               </div>
+                            </div>
+                            <div className="p-3 space-y-1">
+                              {reg.checks.map((check, i) => {
+                                const sev = SEV_CONFIG[check.severity] || SEV_CONFIG.MEDIUM;
+                                return (
+                                  <div key={i} className="flex items-center justify-between py-2 px-2 hover:bg-zinc-50 rounded-md">
+                                    <div className="flex-1 min-w-0">
+                                      <p className="text-xs text-zinc-600">{check.description}</p>
+                                      {check.matched_keywords.length > 0 && (
+                                        <p className="text-[10px] text-zinc-400 mt-0.5">Matched: {check.matched_keywords.slice(0, 3).join(", ")}</p>
+                                      )}
+                                    </div>
+                                    <div className="flex items-center gap-2 ml-3">
+                                      <span className={`text-[10px] font-semibold px-1.5 py-0.5 rounded ${sev.bg} ${sev.text}`}>{check.severity}</span>
+                                      <span className="text-sm">{check.status === "PASS" ? "✅" : "❌"}</span>
+                                    </div>
+                                  </div>
+                                );
+                              })}
+                            </div>
                           </div>
+                        );
+                      })}
+                    </div>
+                  )}
                 </div>
               </div>
             ) : (
               <div className="border border-dashed border-zinc-200 rounded-xl h-[420px] flex flex-col items-center justify-center">
                 <ScanText className="w-10 h-10 text-zinc-200 mb-3" />
+                <p className="text-sm text-zinc-300">Paste text and analyze to see results</p>
               </div>
             )}
           </div>

web/app/dashboard-pages/compare/page.tsx ADDED Viewed

	@@ -0,0 +1,283 @@

+"use client";
+import { useState, useRef } from "react";
+import {
+  FileCompare, Upload, ArrowRightLeft, ChevronDown, ChevronUp,
+  TriangleAlert, CircleCheck, AlertTriangle, Copy, Check, X,
+  Loader2, BarChart3
+} from "lucide-react";
+interface CompareResult {
+  alignment_score: number;
+  contract_a_clauses: number;
+  contract_b_clauses: number;
+  added_clauses: Array<{ text: string; type: string }>;
+  removed_clauses: Array<{ text: string; type: string }>;
+  modified_clauses: Array<{ type: string; similarity: number; clause_a: string; clause_b: string; clause_type: string }>;
+  risk_delta: string;
+  risk_winner: string;
+  type_map_a: Record<string, number>;
+  type_map_b: Record<string, number>;
+}
+const EXAMPLE_A = `This Master Service Agreement ("MSA") is entered into as of March 1, 2024 by and between CloudTech Solutions, Inc. ("Provider") and Global Retail Partners LLC ("Customer").
+1. SERVICES. Provider shall provide cloud hosting services as described in Exhibit A.
+2. TERM. The initial term is twelve (12) months, automatically renewing for successive one year periods.
+3. FEES. Customer shall pay a monthly fee of $25,000 within 30 days of invoice.
+4. LIABILITY. Provider's aggregate liability shall not exceed $1,000,000. IN NO EVENT SHALL PROVIDER BE LIABLE FOR LOST PROFITS.
+5. TERMINATION. Either party may terminate for convenience with 90 days notice. Provider may terminate immediately for non-payment.
+6. GOVERNING LAW. This Agreement is governed by the laws of the State of Delaware.`;
+const EXAMPLE_B = `This Master Service Agreement ("MSA") is entered into as of April 15, 2024 by and between CloudTech Solutions, Inc. ("Provider") and Global Retail Partners LLC ("Customer").
+1. SERVICES. Provider shall provide cloud hosting and data processing services as described in Exhibit A and B.
+2. TERM. The initial term is twenty-four (24) months, automatically renewing for successive one year periods unless terminated in accordance with Section 5.
+3. FEES. Customer shall pay a monthly fee of $30,000 within 15 days of invoice. Late payments incur a penalty of 2% per month.
+4. LIABILITY. Provider's aggregate liability shall not exceed $500,000. IN NO EVENT SHALL PROVIDER BE LIABLE FOR LOST PROFITS OR CONSEQUENTIAL DAMAGES.
+5. TERMINATION. Either party may terminate for convenience with 180 days notice. Provider may terminate immediately for non-payment or material breach.
+6. GOVERNING LAW. This Agreement is governed by the laws of the State of New York.`;
+export default function ComparePage() {
+  const [textA, setTextA] = useState("");
+  const [textB, setTextB] = useState("");
+  const [result, setResult] = useState<CompareResult | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState("");
+  const [expandedIdx, setExpandedIdx] = useState<number | null>(null);
+  const [activeSection, setActiveSection] = useState<string>("summary");
+  async function handleCompare() {
+    if (!textA.trim() || textA.trim().length < 50) { setError("Contract A must have at least 50 characters."); return; }
+    if (!textB.trim() || textB.trim().length < 50) { setError("Contract B must have at least 50 characters."); return; }
+    setLoading(true); setError(""); setResult(null); setExpandedIdx(null);
+    try {
+      const res = await fetch("/api/compare", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ text_a: textA, text_b: textB }),
+      });
+      if (!res.ok) throw new Error((await res.json()).error || "Failed");
+      const data = await res.json();
+      setResult(data);
+    } catch (e: any) { setError(e.message); }
+    finally { setLoading(false); }
+  }
+  function loadExamples() {
+    setTextA(EXAMPLE_A);
+    setTextB(EXAMPLE_B);
+  }
+  return (
+    <div className="min-h-screen bg-white">
+      <div className="max-w-7xl mx-auto px-5 py-10">
+        <div className="mb-8">
+          <h1 className="text-2xl font-semibold tracking-tight flex items-center gap-2">
+            <FileCompare className="w-6 h-6 text-zinc-400" />
+            Compare Contracts
+          </h1>
+          <p className="mt-1 text-sm text-zinc-500">Upload or paste two contracts side-by-side. Get clause-level diffs, alignment score, and risk delta.</p>
+        </div>
+        {/* Input area */}
+        <div className="grid lg:grid-cols-2 gap-4 mb-6">
+          <div>
+            <label className="text-sm font-medium text-zinc-700 mb-1.5 flex items-center gap-2">
+              <span className="w-6 h-6 rounded bg-zinc-100 flex items-center justify-center text-xs font-bold text-zinc-600">A</span>
+              Contract A
+            </label>
+            <textarea value={textA} onChange={(e) => setTextA(e.target.value)}
+              placeholder="Paste contract A here..."
+              className="w-full h-[280px] p-4 border border-zinc-200 rounded-xl text-sm leading-relaxed resize-none focus:outline-none focus:ring-2 focus:ring-zinc-900/10 focus:border-zinc-300 placeholder:text-zinc-300 font-mono" />
+          </div>
+          <div>
+            <label className="text-sm font-medium text-zinc-700 mb-1.5 flex items-center gap-2">
+              <span className="w-6 h-6 rounded bg-zinc-100 flex items-center justify-center text-xs font-bold text-zinc-600">B</span>
+              Contract B
+            </label>
+            <textarea value={textB} onChange={(e) => setTextB(e.target.value)}
+              placeholder="Paste contract B here..."
+              className="w-full h-[280px] p-4 border border-zinc-200 rounded-xl text-sm leading-relaxed resize-none focus:outline-none focus:ring-2 focus:ring-zinc-900/10 focus:border-zinc-300 placeholder:text-zinc-300 font-mono" />
+          </div>
+        </div>
+        <div className="flex gap-2 mb-8">
+          <button onClick={handleCompare} disabled={loading}
+            className="inline-flex items-center gap-2 bg-zinc-900 text-white px-5 py-2.5 rounded-lg text-sm font-medium hover:bg-zinc-800 disabled:opacity-40 transition-colors">
+            {loading ? <><Loader2 className="w-4 h-4 animate-spin" /> Comparing...</> : <><ArrowRightLeft className="w-4 h-4" /> Compare Contracts</>}
+          </button>
+          <button onClick={loadExamples} className="px-4 border border-zinc-200 rounded-lg text-sm text-zinc-500 hover:bg-zinc-50 transition-colors">Load Example</button>
+        </div>
+        {error && <p className="mb-6 text-sm text-red-600 flex items-center gap-1.5"><TriangleAlert className="w-3.5 h-3.5" />{error}</p>}
+        {/* Results */}
+        {result && (
+          <div className="space-y-6">
+            {/* Summary */}
+            <div className="grid md:grid-cols-4 gap-4">
+              <div className="border border-zinc-200 rounded-xl p-4 text-center">
+                <p className="text-xs text-zinc-400">Alignment</p>
+                <p className="text-2xl font-bold text-zinc-900">{(result.alignment_score * 100).toFixed(1)}%</p>
+              </div>
+              <div className="border border-zinc-200 rounded-xl p-4 text-center">
+                <p className="text-xs text-zinc-400">Clauses in A</p>
+                <p className="text-2xl font-bold text-zinc-900">{result.contract_a_clauses}</p>
+              </div>
+              <div className="border border-zinc-200 rounded-xl p-4 text-center">
+                <p className="text-xs text-zinc-400">Clauses in B</p>
+                <p className="text-2xl font-bold text-zinc-900">{result.contract_b_clauses}</p>
+              </div>
+              <div className={`border rounded-xl p-4 text-center ${result.risk_winner === "tie" ? "border-emerald-200 bg-emerald-50" : "border-red-200 bg-red-50"}`}>
+                <p className="text-xs text-zinc-400">Risk Winner</p>
+                <p className={`text-sm font-bold ${result.risk_winner === "tie" ? "text-emerald-700" : "text-red-700"}`}>{result.risk_delta}</p>
+              </div>
+            </div>
+            {/* Section tabs */}
+            <div className="border-b border-zinc-200">
+              <div className="flex gap-1">
+                {[
+                  { key: "summary", label: "Summary", count: 0 },
+                  { key: "modified", label: "Modified", count: result.modified_clauses.length },
+                  { key: "added", label: "Added in B", count: result.added_clauses.length },
+                  { key: "removed", label: "Removed from A", count: result.removed_clauses.length },
+                ].map((s) => (
+                  <button key={s.key} onClick={() => setActiveSection(s.key)}
+                    className={`px-3 py-2 text-sm font-medium border-b-2 transition-colors ${activeSection === s.key ? "border-zinc-900 text-zinc-900" : "border-transparent text-zinc-400 hover:text-zinc-600"}`}>
+                    {s.label} {s.count > 0 && <span className="ml-1 text-zinc-400">({s.count})</span>}
+                  </button>
+                ))}
+              </div>
+            </div>
+            {/* Section content */}
+            <div className="max-h-[500px] overflow-y-auto">
+              {/* Modified clauses */}
+              {activeSection === "modified" && (
+                <div className="space-y-3">
+                  {result.modified_clauses.length === 0 ? (
+                    <div className="border border-dashed border-zinc-200 rounded-xl p-10 text-center">
+                      <CircleCheck className="w-8 h-8 text-emerald-400 mx-auto mb-2" />
+                      <p className="text-sm text-zinc-500">No modified clauses detected.</p>
+                    </div>
+                  ) : result.modified_clauses.map((m, i) => {
+                    const isExpanded = expandedIdx === i;
+                    const simColor = m.similarity >= 0.8 ? "text-emerald-600" : m.similarity >= 0.6 ? "text-amber-600" : "text-red-600";
+                    return (
+                      <div key={i} className="border border-zinc-200 rounded-xl overflow-hidden">
+                        <button onClick={() => setExpandedIdx(isExpanded ? null : i)} className="w-full text-left p-4 flex items-start gap-3 hover:bg-zinc-50/50 transition-colors">
+                          <div className="w-8 h-8 rounded-lg bg-amber-50 flex items-center justify-center shrink-0">
+                            <AlertTriangle className="w-4 h-4 text-amber-600" />
+                          </div>
+                          <div className="flex-1 min-w-0">
+                            <div className="flex items-center gap-2">
+                              <span className="text-xs font-medium text-zinc-500 uppercase">{m.clause_type}</span>
+                              <span className={`text-xs font-bold ${simColor}`}>{(m.similarity * 100).toFixed(0)}% similar</span>
+                            </div>
+                            <p className="mt-1 text-sm text-zinc-600 line-clamp-2">{m.clause_a}...</p>
+                          </div>
+                          <div className="shrink-0 mt-1">{isExpanded ? <ChevronUp className="w-4 h-4 text-zinc-400" /> : <ChevronDown className="w-4 h-4 text-zinc-400" />}</div>
+                        </button>
+                        {isExpanded && (
+                          <div className="px-4 pb-4 pt-0 border-t border-zinc-100">
+                            <div className="grid grid-cols-2 gap-3 mt-3">
+                              <div className="bg-red-50 rounded-lg p-3">
+                                <p className="text-[10px] font-semibold text-red-600 uppercase mb-1">Contract A</p>
+                                <p className="text-sm text-zinc-700">{m.clause_a}</p>
+                              </div>
+                              <div className="bg-emerald-50 rounded-lg p-3">
+                                <p className="text-[10px] font-semibold text-emerald-600 uppercase mb-1">Contract B</p>
+                                <p className="text-sm text-zinc-700">{m.clause_b}</p>
+                              </div>
+                            </div>
+                          </div>
+                        )}
+                      </div>
+                    );
+                  })}
+                </div>
+              )}
+              {/* Added clauses */}
+              {activeSection === "added" && (
+                <div className="space-y-2">
+                  {result.added_clauses.length === 0 ? (
+                    <div className="border border-dashed border-zinc-200 rounded-xl p-10 text-center">
+                      <CircleCheck className="w-8 h-8 text-emerald-400 mx-auto mb-2" />
+                      <p className="text-sm text-zinc-500">No new clauses added in Contract B.</p>
+                    </div>
+                  ) : result.added_clauses.map((c, i) => (
+                    <div key={i} className="border-l-4 border-emerald-400 bg-emerald-50/30 rounded-r-xl p-3">
+                      <span className="text-[10px] font-semibold text-emerald-600 uppercase">{c.type}</span>
+                      <p className="text-sm text-zinc-700 mt-1">{c.text}</p>
+                    </div>
+                  ))}
+                </div>
+              )}
+              {/* Removed clauses */}
+              {activeSection === "removed" && (
+                <div className="space-y-2">
+                  {result.removed_clauses.length === 0 ? (
+                    <div className="border border-dashed border-zinc-200 rounded-xl p-10 text-center">
+                      <CircleCheck className="w-8 h-8 text-emerald-400 mx-auto mb-2" />
+                      <p className="text-sm text-zinc-500">No clauses removed from Contract A.</p>
+                    </div>
+                  ) : result.removed_clauses.map((c, i) => (
+                    <div key={i} className="border-l-4 border-red-400 bg-red-50/30 rounded-r-xl p-3">
+                      <span className="text-[10px] font-semibold text-red-600 uppercase">{c.type}</span>
+                      <p className="text-sm text-zinc-700 mt-1">{c.text}</p>
+                    </div>
+                  ))}
+                </div>
+              )}
+              {/* Summary */}
+              {activeSection === "summary" && (
+                <div className="space-y-4">
+                  <div className="grid grid-cols-2 gap-4">
+                    <div className="border border-zinc-200 rounded-xl p-4">
+                      <p className="text-xs font-medium text-zinc-500 mb-2">Contract A Clause Types</p>
+                      {Object.entries(result.type_map_a).map(([type, count]) => (
+                        <div key={type} className="flex justify-between text-sm py-1">
+                          <span className="text-zinc-600 capitalize">{type}</span>
+                          <span className="font-medium text-zinc-900">{count}</span>
+                        </div>
+                      ))}
+                    </div>
+                    <div className="border border-zinc-200 rounded-xl p-4">
+                      <p className="text-xs font-medium text-zinc-500 mb-2">Contract B Clause Types</p>
+                      {Object.entries(result.type_map_b).map(([type, count]) => (
+                        <div key={type} className="flex justify-between text-sm py-1">
+                          <span className="text-zinc-600 capitalize">{type}</span>
+                          <span className="font-medium text-zinc-900">{count}</span>
+                        </div>
+                      ))}
+                    </div>
+                  </div>
+                  <div className="border border-zinc-200 rounded-xl p-4">
+                    <p className="text-xs font-medium text-zinc-500 mb-2">Raw JSON</p>
+                    <pre className="text-xs text-zinc-600 overflow-x-auto bg-zinc-50 rounded-lg p-3">{JSON.stringify(result, null, 2)}</pre>
+                  </div>
+                </div>
+              )}
+            </div>
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}

web/app/dashboard-pages/dashboard/page.tsx CHANGED Viewed

@@ -1,5 +1,9 @@
 import { createClient } from "@/lib/supabase/server";
 import Link from "next/link";
 export default async function DashboardPage() {
   const supabase = await createClient();
@@ -22,6 +26,15 @@ export default async function DashboardPage() {
   const usedThisMonth = profile?.analyses_this_month || 0;
   const limit = plan === "free" ? 10 : "∞";
   return (
     <div className="min-h-screen bg-gray-50">
       <div className="max-w-6xl mx-auto px-6 py-12">
@@ -42,7 +55,7 @@ export default async function DashboardPage() {
         </div>
         {/* Stats */}
-        <div className="grid md:grid-cols-4 gap-6 mb-10">
           <div className="bg-white rounded-xl p-6 border border-gray-200">
             <p className="text-sm text-gray-500">Plan</p>
             <p className="text-2xl font-bold text-gray-900 capitalize mt-1">{plan}</p>
@@ -57,14 +70,63 @@ export default async function DashboardPage() {
           </div>
           <div className="bg-white rounded-xl p-6 border border-gray-200">
             <p className="text-sm text-gray-500">Avg Risk Score</p>
-            <p className="text-2xl font-bold text-gray-900 mt-1">
-              {analyses && analyses.length > 0
-                ? Math.round(analyses.reduce((s, a) => s + a.risk_score, 0) / analyses.length)
-                : "—"}
-            </p>
           </div>
         </div>
         {/* Recent Scans */}
         <div className="bg-white rounded-xl border border-gray-200 overflow-hidden">
           <div className="px-6 py-4 border-b border-gray-100">
@@ -78,9 +140,17 @@ export default async function DashboardPage() {
                     <p className="text-sm font-medium text-gray-900 truncate">
                       {a.source_url || "Manual scan"}
                     </p>
-                    <p className="text-xs text-gray-500 mt-1">
-                      {new Date(a.created_at).toLocaleDateString()} · {a.total_clauses} clauses · {a.flagged_count} flagged
-                    </p>
                   </div>
                   <div className="flex items-center gap-3">
                     <span className={`text-sm font-bold px-3 py-1 rounded-full ${
@@ -108,7 +178,7 @@ export default async function DashboardPage() {
           <div className="mt-8 bg-indigo-50 border border-indigo-200 rounded-xl p-6 flex items-center justify-between">
             <div>
               <p className="font-semibold text-indigo-900">Upgrade to Pro</p>
-              <p className="text-sm text-indigo-700 mt-1">Unlimited scans, AI explanations, PDF exports, and more.</p>
             </div>
             <Link
               href="/#pricing"

 import { createClient } from "@/lib/supabase/server";
 import Link from "next/link";
+import {
+  ScanText, ShieldCheck, TriangleAlert, Tag, AlertTriangle,
+  ClipboardList, FileCompare, TrendingUp, Clock
+} from "lucide-react";
 export default async function DashboardPage() {
   const supabase = await createClient();
   const usedThisMonth = profile?.analyses_this_month || 0;
   const limit = plan === "free" ? 10 : "∞";
+  // Calculate stats
+  const avgRisk = analyses && analyses.length > 0
+    ? Math.round(analyses.reduce((s, a) => s + a.risk_score, 0) / analyses.length)
+    : null;
+  const totalEntities = analyses?.reduce((s, a) => s + (a.entities?.length || 0), 0) || 0;
+  const totalContradictions = analyses?.reduce((s, a) => s + (a.contradictions?.length || 0), 0) || 0;
+  const totalObligations = analyses?.reduce((s, a) => s + (a.obligations?.length || 0), 0) || 0;
   return (
     <div className="min-h-screen bg-gray-50">
       <div className="max-w-6xl mx-auto px-6 py-12">
         </div>
         {/* Stats */}
+        <div className="grid md:grid-cols-2 lg:grid-cols-4 gap-6 mb-10">
           <div className="bg-white rounded-xl p-6 border border-gray-200">
             <p className="text-sm text-gray-500">Plan</p>
             <p className="text-2xl font-bold text-gray-900 capitalize mt-1">{plan}</p>
           </div>
           <div className="bg-white rounded-xl p-6 border border-gray-200">
             <p className="text-sm text-gray-500">Avg Risk Score</p>
+            <p className="text-2xl font-bold text-gray-900 mt-1">{avgRisk !== null ? avgRisk : "—"}</p>
+          </div>
+        </div>
+        {/* Extended Stats v2 */}
+        <div className="grid md:grid-cols-3 gap-6 mb-10">
+          <div className="bg-white rounded-xl p-6 border border-gray-200 flex items-center gap-4">
+            <div className="w-10 h-10 rounded-lg bg-blue-50 flex items-center justify-center">
+              <Tag className="w-5 h-5 text-blue-600" />
+            </div>
+            <div>
+              <p className="text-sm text-gray-500">Entities Extracted</p>
+              <p className="text-xl font-bold text-gray-900">{totalEntities}</p>
+            </div>
+          </div>
+          <div className="bg-white rounded-xl p-6 border border-gray-200 flex items-center gap-4">
+            <div className="w-10 h-10 rounded-lg bg-amber-50 flex items-center justify-center">
+              <AlertTriangle className="w-5 h-5 text-amber-600" />
+            </div>
+            <div>
+              <p className="text-sm text-gray-500">Contradictions Found</p>
+              <p className="text-xl font-bold text-gray-900">{totalContradictions}</p>
+            </div>
+          </div>
+          <div className="bg-white rounded-xl p-6 border border-gray-200 flex items-center gap-4">
+            <div className="w-10 h-10 rounded-lg bg-emerald-50 flex items-center justify-center">
+              <ClipboardList className="w-5 h-5 text-emerald-600" />
+            </div>
+            <div>
+              <p className="text-sm text-gray-500">Obligations Tracked</p>
+              <p className="text-xl font-bold text-gray-900">{totalObligations}</p>
+            </div>
           </div>
         </div>
+        {/* Quick Actions */}
+        <div className="grid md:grid-cols-2 gap-6 mb-10">
+          <Link href="/dashboard-pages/analyze" className="bg-white rounded-xl p-6 border border-gray-200 hover:border-indigo-200 hover:shadow-sm transition-all group">
+            <div className="flex items-center gap-3 mb-2">
+              <div className="w-10 h-10 rounded-lg bg-indigo-50 flex items-center justify-center group-hover:bg-indigo-100 transition-colors">
+                <ScanText className="w-5 h-5 text-indigo-600" />
+              </div>
+              <h3 className="font-semibold text-gray-900">Analyze Contract</h3>
+            </div>
+            <p className="text-sm text-gray-500">Scan a contract for 41 clause types, risk scoring, NER, and compliance.</p>
+          </Link>
+          <Link href="/dashboard-pages/compare" className="bg-white rounded-xl p-6 border border-gray-200 hover:border-indigo-200 hover:shadow-sm transition-all group">
+            <div className="flex items-center gap-3 mb-2">
+              <div className="w-10 h-10 rounded-lg bg-indigo-50 flex items-center justify-center group-hover:bg-indigo-100 transition-colors">
+                <FileCompare className="w-5 h-5 text-indigo-600" />
+              </div>
+              <h3 className="font-semibold text-gray-900">Compare Contracts</h3>
+            </div>
+            <p className="text-sm text-gray-500">Side-by-side diff with alignment scoring and risk delta analysis.</p>
+          </Link>
+        </div>
         {/* Recent Scans */}
         <div className="bg-white rounded-xl border border-gray-200 overflow-hidden">
           <div className="px-6 py-4 border-b border-gray-100">
                     <p className="text-sm font-medium text-gray-900 truncate">
                       {a.source_url || "Manual scan"}
                     </p>
+                    <div className="flex items-center gap-3 mt-1">
+                      <p className="text-xs text-gray-500">
+                        {new Date(a.created_at).toLocaleDateString()} · {a.total_clauses} clauses · {a.flagged_count} flagged
+                      </p>
+                      {a.entities && a.entities.length > 0 && (
+                        <span className="text-[10px] bg-blue-50 text-blue-600 px-1.5 py-0.5 rounded">{a.entities.length} entities</span>
+                      )}
+                      {a.contradictions && a.contradictions.length > 0 && (
+                        <span className="text-[10px] bg-amber-50 text-amber-600 px-1.5 py-0.5 rounded">{a.contradictions.length} issues</span>
+                      )}
+                    </div>
                   </div>
                   <div className="flex items-center gap-3">
                     <span className={`text-sm font-bold px-3 py-1 rounded-full ${
           <div className="mt-8 bg-indigo-50 border border-indigo-200 rounded-xl p-6 flex items-center justify-between">
             <div>
               <p className="font-semibold text-indigo-900">Upgrade to Pro</p>
+              <p className="text-sm text-indigo-700 mt-1">Unlimited scans, contract comparison, PDF exports, and team features.</p>
             </div>
             <Link
               href="/#pricing"

web/app/page.tsx CHANGED Viewed

@@ -2,45 +2,54 @@ import Link from "next/link";
 import {
   ShieldCheck, ShieldAlert, Scale, Gavel, ScrollText, Handshake,
   ScanText, FileCheck, TriangleAlert, ArrowRight, Zap, Eye, Download,
-  ChevronRight, Sparkles, Lock, Globe, Ban, FileX, Stamp
 } from "lucide-react";
 const CLAUSES = [
-  { icon: Scale, name: "Arbitration", desc: "Waives your right to sue in court", severity: "high" },
-  { icon: ShieldAlert, name: "Liability limits", desc: "Company avoids responsibility for damages", severity: "high" },
-  { icon: Ban, name: "Unilateral termination", desc: "They can close your account without reason", severity: "high" },
-  { icon: FileX, name: "Unilateral change", desc: "Terms can change without your consent", severity: "medium" },
-  { icon: Eye, name: "Content removal", desc: "Your content deleted without notice", severity: "medium" },
   { icon: Globe, name: "Jurisdiction", desc: "Disputes handled in their preferred court", severity: "medium" },
   { icon: Gavel, name: "Choice of law", desc: "Foreign law overrides your local protections", severity: "medium" },
-  { icon: Stamp, name: "Contract by using", desc: "You agree just by visiting the site", severity: "low" },
 ];
 const STEPS = [
-  { icon: Download, title: "Install", desc: "Add the Chrome extension. Two clicks, no signup required." },
-  { icon: ScanText, title: "Browse normally", desc: "Visit any terms page. ClauseGuard scans it in the background." },
-  { icon: TriangleAlert, title: "See the flags", desc: "Unfair clauses get highlighted. Open the sidebar for the full breakdown." },
 ];
 const PRICING = [
   {
     name: "Free", price: "₹0", period: "", highlight: false, cta: "Get started",
-    features: ["10 scans per month", "All 8 clause types", "Risk score and grade", "Chrome extension", "Local fallback"],
   },
   {
     name: "Pro", price: "₹999", period: "/mo", highlight: true, cta: "Start free trial",
-    features: ["Unlimited scans", "Upload contracts and leases", "AI clause explanations", "Scan history", "PDF report export", "Email scan reports", "Priority support"],
   },
   {
     name: "Team", price: "₹3,999", period: "/mo", highlight: false, cta: "Talk to us",
-    features: ["Everything in Pro", "5 team seats", "10,000 API calls", "Shared dashboard", "Slack support", "Custom clause rules"],
   },
 ];
 const sevColor: Record<string, string> = {
-  high: "text-red-500 bg-red-50",
-  medium: "text-amber-500 bg-amber-50",
-  low: "text-blue-500 bg-blue-50",
 };
 export default function Home() {
@@ -51,27 +60,26 @@ export default function Home() {
         <div className="max-w-2xl">
           <div className="inline-flex items-center gap-2 px-3 py-1 rounded-full border border-zinc-200 text-[13px] text-zinc-500 mb-6">
             <Sparkles className="w-3.5 h-3.5 text-zinc-400" />
-            Trained on 9,414 legal clauses
           </div>
           <h1 className="text-[42px] sm:text-5xl font-semibold tracking-tight leading-[1.1]">
             Know what you are<br />agreeing to
           </h1>
           <p className="mt-5 text-[17px] text-zinc-500 leading-relaxed max-w-lg">
-            ClauseGuard scans Terms of Service, contracts, and leases for unfair clauses.
-            Get a clear risk score before you click accept.
           </p>
           <div className="mt-8 flex flex-wrap gap-3">
             <Link href="/dashboard-pages/analyze" className="inline-flex items-center gap-2 bg-zinc-900 text-white px-5 py-2.5 rounded-lg text-sm font-medium hover:bg-zinc-800 transition-colors">
-              <Download className="w-4 h-4" />
-              Add to Chrome
-            </Link>
-            <Link href="/dashboard-pages/analyze"
-              className="inline-flex items-center gap-2 border border-zinc-200 px-5 py-2.5 rounded-lg text-sm font-medium hover:bg-zinc-50 transition-colors">
               Try the scanner
               <ArrowRight className="w-4 h-4" />
             </Link>
           </div>
-          <p className="mt-4 text-xs text-zinc-400">No account needed for free tier</p>
         </div>
       </section>
@@ -82,15 +90,15 @@ export default function Home() {
             <ShieldCheck className="w-4 h-4 text-zinc-400" />
             <p className="text-[13px] font-medium text-zinc-400 uppercase tracking-wider">Detection</p>
           </div>
-          <h2 className="text-2xl font-semibold tracking-tight">Eight types of unfair clauses</h2>
           <p className="mt-2 text-zinc-500 text-[15px] max-w-lg">
-            Based on the CLAUDETTE taxonomy — the same framework used by EU consumer protection researchers.
           </p>
           <div className="mt-10 grid sm:grid-cols-2 lg:grid-cols-4 gap-3">
             {CLAUSES.map((c) => (
               <div key={c.name} className="group border border-zinc-100 rounded-xl p-4 hover:border-zinc-200 hover:shadow-sm transition-all cursor-default">
-                <div className={`w-8 h-8 rounded-lg flex items-center justify-center ${sevColor[c.severity]}`}>
                   <c.icon className="w-4 h-4" />
                 </div>
                 <p className="mt-3 text-sm font-medium">{c.name}</p>
@@ -108,7 +116,7 @@ export default function Home() {
             <Zap className="w-4 h-4 text-zinc-400" />
             <p className="text-[13px] font-medium text-zinc-400 uppercase tracking-wider">How it works</p>
           </div>
-          <h2 className="text-2xl font-semibold tracking-tight">Three steps, under two seconds</h2>
           <div className="mt-10 grid sm:grid-cols-3 gap-8">
             {STEPS.map((s, i) => (
@@ -127,6 +135,33 @@ export default function Home() {
         </div>
       </section>
       {/* Pricing */}
       <section id="pricing" className="border-t border-zinc-100">
         <div className="max-w-6xl mx-auto px-5 py-20">
@@ -137,9 +172,7 @@ export default function Home() {
             {PRICING.map((plan) => (
               <div key={plan.name}
                 className={`rounded-xl p-6 transition-shadow ${
-                  plan.highlight
-                    ? "border-2 border-zinc-900 shadow-sm"
-                    : "border border-zinc-200"
                 }`}>
                 <p className="text-[13px] font-medium text-zinc-400">{plan.name}</p>
                 <p className="mt-2 flex items-baseline gap-1">
@@ -156,9 +189,7 @@ export default function Home() {
                 </ul>
                 <Link href={plan.name === "Free" ? "/auth/signup" : plan.name === "Team" ? "mailto:hello@clauseguardweb.netlify.app" : "/auth/signup"}
                   className={`mt-6 block w-full py-2.5 rounded-lg text-[13px] font-medium text-center transition-colors ${
-                  plan.highlight
-                    ? "bg-zinc-900 text-white hover:bg-zinc-800"
-                    : "border border-zinc-200 text-zinc-700 hover:bg-zinc-50"
                 }`}>
                   {plan.cta}
                 </Link>
@@ -176,11 +207,15 @@ export default function Home() {
           <p className="mt-2 text-[15px] text-zinc-500 max-w-md mx-auto">
             Join thousands protecting themselves before clicking accept.
           </p>
-          <div className="mt-6">
             <Link href="/auth/signup" className="inline-flex items-center gap-2 bg-zinc-900 text-white px-6 py-3 rounded-lg text-sm font-medium hover:bg-zinc-800 transition-colors">
-              <Download className="w-4 h-4" />
               Get started free
             </Link>
           </div>
         </div>
       </section>

 import {
   ShieldCheck, ShieldAlert, Scale, Gavel, ScrollText, Handshake,
   ScanText, FileCheck, TriangleAlert, ArrowRight, Zap, Eye, Download,
+  ChevronRight, Sparkles, Lock, Globe, Ban, FileX, Stamp, Layers,
+  Tag, AlertTriangle, ClipboardList, Landmark, Building, DollarSign,
+  MapPin, Hash, BookOpen, CheckCircle
 } from "lucide-react";
 const CLAUSES = [
+  { icon: Scale, name: "Arbitration", desc: "Waives your right to sue in court", severity: "critical" },
+  { icon: ShieldAlert, name: "Liability limits", desc: "Company avoids responsibility for damages", severity: "critical" },
+  { icon: Ban, name: "Unilateral termination", desc: "They can close your account without reason", severity: "critical" },
+  { icon: FileX, name: "Unilateral change", desc: "Terms can change without your consent", severity: "high" },
+  { icon: Eye, name: "Content removal", desc: "Your content deleted without notice", severity: "high" },
   { icon: Globe, name: "Jurisdiction", desc: "Disputes handled in their preferred court", severity: "medium" },
   { icon: Gavel, name: "Choice of law", desc: "Foreign law overrides your local protections", severity: "medium" },
+  { icon: Lock, name: "IP Ownership", desc: "Intellectual property transferred entirely", severity: "critical" },
+  { icon: Layers, name: "41 CUAD Categories", desc: "Full taxonomy: NDA, MSA, SLA, and more", severity: "low" },
+  { icon: Tag, name: "Legal NER", desc: "Extract parties, dates, money, jurisdictions", severity: "low" },
+  { icon: AlertTriangle, name: "Contradictions", desc: "Detect conflicting clauses automatically", severity: "high" },
+  { icon: ClipboardList, name: "Obligations", desc: "Track monetary, compliance, reporting tasks", severity: "medium" },
+  { icon: Landmark, name: "Compliance", desc: "GDPR, CCPA, SOX, HIPAA, FINRA checks", severity: "high" },
+  { icon: BookOpen, name: "Compare Contracts", desc: "Side-by-side diff with alignment scoring", severity: "low" },
 ];
 const STEPS = [
+  { icon: Download, title: "Upload or paste", desc: "Drop a PDF, DOCX, or paste contract text directly." },
+  { icon: ScanText, title: "AI scans 41 categories", desc: "Legal-BERT + CUAD detects clauses, risks, entities." },
+  { icon: TriangleAlert, title: "Get actionable insights", desc: "Risk score, contradictions, obligations, compliance gaps." },
 ];
 const PRICING = [
   {
     name: "Free", price: "₹0", period: "", highlight: false, cta: "Get started",
+    features: ["10 scans per month", "41 clause categories", "Risk scoring", "Legal NER", "Contradiction detection", "Compliance checks"],
   },
   {
     name: "Pro", price: "₹999", period: "/mo", highlight: true, cta: "Start free trial",
+    features: ["Unlimited scans", "Upload PDF/DOCX files", "Contract comparison", "AI clause explanations", "Scan history", "PDF report export", "Obligation tracker", "Priority support"],
   },
   {
     name: "Team", price: "₹3,999", period: "/mo", highlight: false, cta: "Talk to us",
+    features: ["Everything in Pro", "5 team seats", "10,000 API calls", "Shared dashboard", "Slack support", "Custom clause rules", "Enterprise compliance"],
   },
 ];
 const sevColor: Record<string, string> = {
+  critical: "text-red-500 bg-red-50 border-red-200",
+  high: "text-amber-500 bg-amber-50 border-amber-200",
+  medium: "text-blue-500 bg-blue-50 border-blue-200",
+  low: "text-emerald-500 bg-emerald-50 border-emerald-200",
 };
 export default function Home() {
         <div className="max-w-2xl">
           <div className="inline-flex items-center gap-2 px-3 py-1 rounded-full border border-zinc-200 text-[13px] text-zinc-500 mb-6">
             <Sparkles className="w-3.5 h-3.5 text-zinc-400" />
+            Trained on 13,000+ legal clauses across 41 categories
           </div>
           <h1 className="text-[42px] sm:text-5xl font-semibold tracking-tight leading-[1.1]">
             Know what you are<br />agreeing to
           </h1>
           <p className="mt-5 text-[17px] text-zinc-500 leading-relaxed max-w-lg">
+            ClauseGuard scans contracts, terms of service, and leases using AI trained on legal data.
+            Get clause detection, risk scoring, entity extraction, contradiction alerts, and compliance checks.
           </p>
           <div className="mt-8 flex flex-wrap gap-3">
             <Link href="/dashboard-pages/analyze" className="inline-flex items-center gap-2 bg-zinc-900 text-white px-5 py-2.5 rounded-lg text-sm font-medium hover:bg-zinc-800 transition-colors">
+              <ScanText className="w-4 h-4" />
               Try the scanner
+            </Link>
+            <Link href="/dashboard-pages/compare" className="inline-flex items-center gap-2 border border-zinc-200 px-5 py-2.5 rounded-lg text-sm font-medium hover:bg-zinc-50 transition-colors">
+              Compare contracts
               <ArrowRight className="w-4 h-4" />
             </Link>
           </div>
+          <p className="mt-4 text-xs text-zinc-400">No account needed for free tier · 10 scans/month</p>
         </div>
       </section>
             <ShieldCheck className="w-4 h-4 text-zinc-400" />
             <p className="text-[13px] font-medium text-zinc-400 uppercase tracking-wider">Detection</p>
           </div>
+          <h2 className="text-2xl font-semibold tracking-tight">14 powerful analysis features</h2>
           <p className="mt-2 text-zinc-500 text-[15px] max-w-lg">
+            Based on the CUAD taxonomy + CLAUDETTE framework — the same datasets used by EU consumer protection researchers and Stanford NLP.
           </p>
           <div className="mt-10 grid sm:grid-cols-2 lg:grid-cols-4 gap-3">
             {CLAUSES.map((c) => (
               <div key={c.name} className="group border border-zinc-100 rounded-xl p-4 hover:border-zinc-200 hover:shadow-sm transition-all cursor-default">
+                <div className={`w-8 h-8 rounded-lg flex items-center justify-center border ${sevColor[c.severity]}`}>
                   <c.icon className="w-4 h-4" />
                 </div>
                 <p className="mt-3 text-sm font-medium">{c.name}</p>
             <Zap className="w-4 h-4 text-zinc-400" />
             <p className="text-[13px] font-medium text-zinc-400 uppercase tracking-wider">How it works</p>
           </div>
+          <h2 className="text-2xl font-semibold tracking-tight">Three steps, under 30 seconds</h2>
           <div className="mt-10 grid sm:grid-cols-3 gap-8">
             {STEPS.map((s, i) => (
         </div>
       </section>
+      {/* Models */}
+      <section className="border-t border-zinc-100">
+        <div className="max-w-6xl mx-auto px-5 py-20">
+          <div className="flex items-center gap-2 mb-2">
+            <CheckCircle className="w-4 h-4 text-zinc-400" />
+            <p className="text-[13px] font-medium text-zinc-400 uppercase tracking-wider">Technology</p>
+          </div>
+          <h2 className="text-2xl font-semibold tracking-tight">Built on production-grade models</h2>
+          <div className="mt-8 grid sm:grid-cols-2 lg:grid-cols-3 gap-4">
+            {[
+              { name: "Legal-BERT + CUAD", desc: "41 clause categories fine-tuned on 510 contracts, 13K annotations", source: "Mokshith31/legalbert-contract-clause-classification" },
+              { name: "Legal NER Engine", desc: "Regex + pattern-based extraction for parties, dates, money, jurisdictions, defined terms", source: "Custom" },
+              { name: "NLI Detection", desc: "Heuristic contradiction detection: liability caps, governing law conflicts, IP ownership", source: "Custom" },
+              { name: "Compliance Engine", desc: "GDPR, CCPA, SOX, HIPAA, FINRA keyword matching with severity scoring", source: "Custom" },
+              { name: "Obligation Tracker", desc: "Extracts monetary, compliance, reporting, delivery, and termination obligations", source: "Custom" },
+              { name: "Comparison Engine", desc: "SequenceMatcher-based clause alignment with risk delta analysis", source: "Custom" },
+            ].map((m) => (
+              <div key={m.name} className="border border-zinc-100 rounded-xl p-4 hover:border-zinc-200 transition-all">
+                <p className="text-sm font-medium text-zinc-900">{m.name}</p>
+                <p className="text-[13px] text-zinc-500 mt-1 leading-relaxed">{m.desc}</p>
+                <p className="text-[11px] text-zinc-400 mt-2">{m.source}</p>
+              </div>
+            ))}
+          </div>
+        </div>
+      </section>
       {/* Pricing */}
       <section id="pricing" className="border-t border-zinc-100">
         <div className="max-w-6xl mx-auto px-5 py-20">
             {PRICING.map((plan) => (
               <div key={plan.name}
                 className={`rounded-xl p-6 transition-shadow ${
+                  plan.highlight ? "border-2 border-zinc-900 shadow-sm" : "border border-zinc-200"
                 }`}>
                 <p className="text-[13px] font-medium text-zinc-400">{plan.name}</p>
                 <p className="mt-2 flex items-baseline gap-1">
                 </ul>
                 <Link href={plan.name === "Free" ? "/auth/signup" : plan.name === "Team" ? "mailto:hello@clauseguardweb.netlify.app" : "/auth/signup"}
                   className={`mt-6 block w-full py-2.5 rounded-lg text-[13px] font-medium text-center transition-colors ${
+                  plan.highlight ? "bg-zinc-900 text-white hover:bg-zinc-800" : "border border-zinc-200 text-zinc-700 hover:bg-zinc-50"
                 }`}>
                   {plan.cta}
                 </Link>
           <p className="mt-2 text-[15px] text-zinc-500 max-w-md mx-auto">
             Join thousands protecting themselves before clicking accept.
           </p>
+          <div className="mt-6 flex gap-3 justify-center">
             <Link href="/auth/signup" className="inline-flex items-center gap-2 bg-zinc-900 text-white px-6 py-3 rounded-lg text-sm font-medium hover:bg-zinc-800 transition-colors">
+              <ScanText className="w-4 h-4" />
               Get started free
             </Link>
+            <Link href="/dashboard-pages/compare" className="inline-flex items-center gap-2 border border-zinc-200 px-6 py-3 rounded-lg text-sm font-medium hover:bg-zinc-50 transition-colors">
+              <ArrowRight className="w-4 h-4" />
+              Compare contracts
+            </Link>
           </div>
         </div>
       </section>

web/components/nav.tsx CHANGED Viewed

@@ -2,7 +2,7 @@
 import Link from "next/link";
 import { usePathname } from "next/navigation";
-import { ShieldCheck, Menu, X, Crown } from "lucide-react";
 import { useState, useEffect } from "react";
 import { createClient } from "@/lib/supabase/client";
@@ -10,6 +10,7 @@ const links = [
   { href: "/#features", label: "Features" },
   { href: "/#pricing", label: "Pricing" },
   { href: "/dashboard-pages/analyze", label: "Scanner" },
 ];
 const ADMIN_EMAILS = ["ankygaur9972@gmail.com"];
@@ -34,6 +35,7 @@ export function Nav() {
         <Link href="/" className="flex items-center gap-2">
           <ShieldCheck className="w-5 h-5 text-zinc-900" strokeWidth={2.2} />
           <span className="font-semibold text-[15px] tracking-tight text-zinc-900">ClauseGuard</span>
         </Link>
         <div className="hidden md:flex items-center gap-1">

 import Link from "next/link";
 import { usePathname } from "next/navigation";
+import { ShieldCheck, Menu, X, Crown, FileCompare } from "lucide-react";
 import { useState, useEffect } from "react";
 import { createClient } from "@/lib/supabase/client";
   { href: "/#features", label: "Features" },
   { href: "/#pricing", label: "Pricing" },
   { href: "/dashboard-pages/analyze", label: "Scanner" },
+  { href: "/dashboard-pages/compare", label: "Compare", icon: FileCompare },
 ];
 const ADMIN_EMAILS = ["ankygaur9972@gmail.com"];
         <Link href="/" className="flex items-center gap-2">
           <ShieldCheck className="w-5 h-5 text-zinc-900" strokeWidth={2.2} />
           <span className="font-semibold text-[15px] tracking-tight text-zinc-900">ClauseGuard</span>
+          <span className="hidden sm:inline text-[10px] font-medium text-zinc-400 ml-1 border border-zinc-200 px-1.5 py-0.5 rounded">v2.0</span>
         </Link>
         <div className="hidden md:flex items-center gap-1">

web/lib/supabase/schema.sql CHANGED Viewed

@@ -1,4 +1,4 @@
--- ClauseGuard — Full Database Schema
 -- Tables ordered by dependency (no forward references)
 -- ─── 1. Teams (no dependencies) ───
@@ -42,7 +42,7 @@ CREATE TABLE IF NOT EXISTS public.team_invites (
   UNIQUE(team_id, email)
 );
--- ─── 4. Analyses (depends on profiles, teams) ───
 CREATE TABLE IF NOT EXISTS public.analyses (
   id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
   user_id UUID REFERENCES public.profiles ON DELETE CASCADE NOT NULL,
@@ -54,6 +54,13 @@ CREATE TABLE IF NOT EXISTS public.analyses (
   risk_score INT NOT NULL CHECK (risk_score >= 0 AND risk_score <= 100),
   grade CHAR(1) NOT NULL CHECK (grade IN ('A', 'B', 'C', 'D', 'F')),
   clauses JSONB NOT NULL DEFAULT '[]',
   created_at TIMESTAMPTZ DEFAULT NOW()
 );
@@ -178,8 +185,8 @@ CREATE TRIGGER on_auth_user_created
   FOR EACH ROW EXECUTE FUNCTION public.handle_new_user();
 -- ─── Set admin ───
--- Run this AFTER your first signup with ankygaur9972@gmail.com:
--- UPDATE public.profiles SET role = 'admin' WHERE email = 'ankygaur9972@gmail.com';
 -- ─── Monthly reset function ───
 CREATE OR REPLACE FUNCTION public.reset_monthly_usage()

+-- ClauseGuard — Full Database Schema v2.0
 -- Tables ordered by dependency (no forward references)
 -- ─── 1. Teams (no dependencies) ───
   UNIQUE(team_id, email)
 );
+-- ─── 4. Analyses (depends on profiles, teams) — v2.0 with full analysis data ───
 CREATE TABLE IF NOT EXISTS public.analyses (
   id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
   user_id UUID REFERENCES public.profiles ON DELETE CASCADE NOT NULL,
   risk_score INT NOT NULL CHECK (risk_score >= 0 AND risk_score <= 100),
   grade CHAR(1) NOT NULL CHECK (grade IN ('A', 'B', 'C', 'D', 'F')),
   clauses JSONB NOT NULL DEFAULT '[]',
+  entities JSONB DEFAULT '[]',
+  contradictions JSONB DEFAULT '[]',
+  obligations JSONB DEFAULT '[]',
+  compliance JSONB DEFAULT '{}',
+  raw_text TEXT,
+  model TEXT DEFAULT 'regex',
+  latency_ms INT DEFAULT 0,
   created_at TIMESTAMPTZ DEFAULT NOW()
 );
   FOR EACH ROW EXECUTE FUNCTION public.handle_new_user();
 -- ─── Set admin ───
+-- Run this AFTER your first signup with your email:
+-- UPDATE public.profiles SET role = 'admin' WHERE email = 'your-email@example.com';
 -- ─── Monthly reset function ───
 CREATE OR REPLACE FUNCTION public.reset_monthly_usage()