python -m venv venv
source venv/bin/activate
pip install PyPDF2 spacy openai pydantic
python -m spacy download en_core_web_sm

# document/parser.py
from PyPDF2 import PdfReader
from typing import Dict, List
import re

class DocumentParser:
    def __init__(self):
        self.section_patterns = [
            r"(?:ARTICLE|Section|Clause)\s+\d+",
            r"(?:TERM|OBLIGATION|LIABILITY|INDEMNIFICATION|CONFIDENTIALITY)",
            r"(?:GOVERNING LAW|DISPUTE RESOLUTION|TERMINATION)",
        ]

    def extract_text(self, pdf_path: str) -> str:
        reader = PdfReader(pdf_path)
        return "\n".join(page.extract_text() or "" for page in reader.pages)

    def extract_sections(self, text: str) -> List[Dict]:
        sections = []
        current_section = {"title": "Preamble", "content": ""}
        lines = text.split("\n")
        for line in lines:
            if any(re.search(p, line, re.IGNORECASE) for p in self.section_patterns):
                if current_section["content"].strip():
                    sections.append(current_section)
                current_section = {"title": line.strip(), "content": ""}
            else:
                current_section["content"] += line + "\n"
        if current_section["content"].strip():
            sections.append(current_section)
        return sections

    def extract_parties(self, text: str) -> List[str]:
        party_pattern = r"(?:between|by and between)\s+(.+?)(?:\s+and\s+|\s+,\s*)"
        return re.findall(party_pattern, text, re.IGNORECASE)

    def extract_dates(self, text: str) -> List[str]:
        date_pattern = r"\b\d{1,2}[/-]\d{1,2}[/-]\d{2,4}\b|\b(?:January|February|March|April|May|June|July|August|September|October|November|December)\s+\d{1,2},?\s+\d{4}\b"
        return re.findall(date_pattern, text)

# analysis/clause_extractor.py
import json
from typing import Dict, List
from openai import OpenAI

class ClauseExtractor:
    def __init__(self, model: str = "gpt-4o"):
        self.client = OpenAI()
        self.model = model
        self.clause_types = [
            "termination", "liability", "indemnification", "confidentiality",
            "intellectual_property", "payment_terms", "warranty", "dispute_resolution",
            "governing_law", "force_majeure", "non_compete", "data_protection",
        ]

    def extract_clauses(self, sections: List[Dict]) -> List[Dict]:
        clauses = []
        for section in sections:
            if len(section["content"].strip()) < 50:
                continue
            response = self.client.chat.completions.create(
                model=self.model,
                messages=[
                    {"role": "system", "content": f"""Extract legal clauses. For each clause return JSON array:
                    [{{"type": "clause_type", "title": "descriptive title",
                     "content": "clause text", "key_terms": ["term1", "term2"],
                     "obligations": ["party: obligation"]}}]
                    Types: {', '.join(self.clause_types)}"""},
                    {"role": "user", "content": f"Section: {section['title']}\n\n{section['content'][:2000]}"},
                ],
                temperature=0.0,
            )
            try:
                extracted = json.loads(response.choices[0].message.content)
                if isinstance(extracted, list):
                    clauses.extend(extracted)
            except (json.JSONDecodeError, IndexError):
                continue
        return clauses

# analysis/risk_scorer.py
import json
from typing import Dict, List
from openai import OpenAI

class RiskScorer:
    def __init__(self, model: str = "gpt-4o"):
        self.client = OpenAI()
        self.model = model

    def score_clause(self, clause: Dict) -> Dict:
        response = self.client.chat.completions.create(
            model=self.model,
            messages=[
                {"role": "system", "content": """Score clause risk 1-10 and return JSON:
                {{"risk_score": 1-10, "risk_level": "low|medium|high|critical",
                 "issues": ["list of specific issues"],
                 "recommendations": ["list of suggestions"]}}"""},
                {"role": "user", "content": f"Type: {clause['type']}\nContent: {clause['content']}"},
            ],
            temperature=0.0,
        )
        try:
            return json.loads(response.choices[0].message.content)
        except (json.JSONDecodeError, IndexError):
            return {"risk_score": 5, "risk_level": "medium", "issues": [], "recommendations": []}

    def score_contract(self, clauses: List[Dict]) -> Dict:
        scored = []
        for clause in clauses:
            risk = self.score_clause(clause)
            scored.append({**clause, **risk})
        risk_scores = [c["risk_score"] for c in scored]
        overall_risk = sum(risk_scores) / len(risk_scores) if risk_scores else 5
        return {
            "clauses": scored,
            "overall_risk_score": round(overall_risk, 1),
            "overall_risk_level": self._risk_level(overall_risk),
            "high_risk_count": sum(1 for s in risk_scores if s >= 7),
            "critical_count": sum(1 for s in risk_scores if s >= 9),
        }

    def _risk_level(self, score: float) -> str:
        if score < 3: return "low"
        if score < 5: return "medium"
        if score < 7: return "high"
        return "critical"

# analysis/compliance_checker.py
import json
from typing import Dict, List
from openai import OpenAI

class ComplianceChecker:
    def __init__(self, model: str = "gpt-4o"):
        self.client = OpenAI()
        self.model = model
        self.regulations = {
            "gdpr": "EU General Data Protection Regulation",
            "ccpa": "California Consumer Privacy Act",
            "hipaa": "Health Insurance Portability and Accountability Act",
            "sox": "Sarbanes-Oxley Act",
        }

    def check_compliance(self, clauses: List[Dict], applicable_regs: List[str]) -> Dict:
        clause_text = "\n\n".join([f"[{c['type']}] {c['content'][:500]}" for c in clauses[:15]])
        response = self.client.chat.completions.create(
            model=self.model,
            messages=[
                {"role": "system", "content": f"""Check compliance against: {', '.join(applicable_regs)}.
                Return JSON: {{"compliant": true/false, "violations": [{{"regulation": "name",
                "clause_type": "type", "issue": "description", "severity": "low|medium|high",
                "recommendation": "fix suggestion"}}], "missing_clauses": ["required clause not found"]}}"""},
                {"role": "user", "content": f"Clauses:\n{clause_text}"},
            ],
            temperature=0.0,
        )
        try:
            return json.loads(response.choices[0].message.content)
        except (json.JSONDecodeError, IndexError):
            return {"compliant": True, "violations": [], "missing_clauses": []}

    def generate_redlines(self, violations: List[Dict]) -> List[Dict]:
        if not violations:
            return []
        response = self.client.chat.completions.create(
            model=self.model,
            messages=[
                {"role": "system", "content": "Generate redline suggestions. For each violation, provide suggested revision."},
                {"role": "user", "content": json.dumps(violations[:5], indent=2)},
            ],
            temperature=0.2,
        )
        try:
            return json.loads(response.choices[0].message.content)
        except (json.JSONDecodeError, IndexError):
            return []

# agent.py
from document.parser import DocumentParser
from analysis.clause_extractor import ClauseExtractor
from analysis.risk_scorer import RiskScorer
from analysis.compliance_checker import ComplianceChecker
from typing import Dict, List

class LegalDocumentAgent:
    def __init__(self, model: str = "gpt-4o"):
        self.parser = DocumentParser()
        self.extractor = ClauseExtractor(model)
        self.risk_scorer = RiskScorer(model)
        self.compliance_checker = ComplianceChecker(model)

    def analyze_contract(self, pdf_path: str, regulations: List[str] = None) -> Dict:
        text = self.parser.extract_text(pdf_path)
        sections = self.parser.extract_sections(text)
        parties = self.parser.extract_parties(text)
        dates = self.parser.extract_dates(text)
        clauses = self.extractor.extract_clauses(sections)
        risk_assessment = self.risk_scorer.score_contract(clauses)
        compliance = self.compliance_checker.check_compliance(clauses, regulations or ["gdpr"])
        redlines = self.compliance_checker.generate_redlines(compliance.get("violations", []))
        return {
            "file": pdf_path,
            "parties": parties,
            "dates": dates,
            "total_clauses": len(clauses),
            "risk_assessment": risk_assessment,
            "compliance": compliance,
            "redlines": redlines,
            "executive_summary": self._generate_summary(clauses, risk_assessment, compliance),
        }

    def compare_contracts(self, path1: str, path2: str) -> Dict:
        analysis1 = self.analyze_contract(path1)
        analysis2 = self.analyze_contract(path2)
        return {
            "contract_1": {"file": path1, "risk": analysis1["risk_assessment"]["overall_risk_score"]},
            "contract_2": {"file": path2, "risk": analysis2["risk_assessment"]["overall_risk_score"]},
            "recommendation": "Proceed with lower-risk contract" if analysis1["risk_assessment"]["overall_risk_score"] < analysis2["risk_assessment"]["overall_risk_score"] else "Contract 2 is lower risk",
        }

    def _generate_summary(self, clauses: List[Dict], risk: Dict, compliance: Dict) -> str:
        return f"Contract contains {len(clauses)} clauses. Overall risk: {risk['overall_risk_level']} ({risk['overall_risk_score']}/10). Compliance: {'Pass' if compliance['compliant'] else 'Issues found'}."