python -m venv venv
source venv/bin/activate
pip install pymupdf python-docx openai pydantic
export OPENAI_API_KEY="sk-your-key"

# document/parser.py
import fitz
from docx import Document
from pathlib import Path
from typing import Dict

class DocumentParser:
    def parse(self, file_path: str) -> Dict:
        path = Path(file_path)
        suffix = path.suffix.lower()
        if suffix == ".pdf":
            return self._parse_pdf(path)
        elif suffix in (".docx", ".doc"):
            return self._parse_docx(path)
        elif suffix == ".txt":
            return {"text": path.read_text(encoding="utf-8"), "pages": 1}
        else:
            return {"error": f"Unsupported format: {suffix}"}

    def _parse_pdf(self, path: Path) -> Dict:
        doc = fitz.open(str(path))
        text_parts = []
        for page in doc:
            text_parts.append(page.get_text())
        doc.close()
        return {
            "text": "\n\n".join(text_parts),
            "pages": len(text_parts),
            "source": str(path),
        }

    def _parse_docx(self, path: Path) -> Dict:
        doc = Document(str(path))
        paragraphs = [p.text for p in doc.paragraphs if p.text.strip()]
        return {
            "text": "\n\n".join(paragraphs),
            "pages": 1,
            "source": str(path),
        }

    def extract_sections(self, text: str) -> Dict[str, str]:
        sections = {}
        current_section = "Preamble"
        current_content = []
        for line in text.split("\n"):
            if self._is_section_header(line):
                if current_content:
                    sections[current_section] = "\n".join(current_content)
                current_section = line.strip()
                current_content = []
            else:
                current_content.append(line)
        if current_content:
            sections[current_section] = "\n".join(current_content)
        return sections

    def _is_section_header(self, line: str) -> bool:
        import re
        patterns = [
            r"^\d+\.\s+[A-Z]",
            r"^[IVXLC]+\.\s+[A-Z]",
            r"^Article\s+\d+",
            r"^Section\s+\d+",
            r"^Article\s+\d+",
            r"^[A-Z][A-Z\s]{5,}$",
        ]
        return any(re.match(p, line.strip()) for p in patterns)

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

class ClauseExtractor:
    def __init__(self, model: str = "gpt-4-turbo-preview"):
        self.client = OpenAI()
        self.model = model

    def extract_clauses(self, text: str) -> List[Dict]:
        response = self.client.chat.completions.create(
            model=self.model,
            messages=[
                {"role": "system", "content": """Extract key clauses from this legal document.
                Return JSON array:
                [{
                    "clause_type": "type (indemnity|limitation|termination|confidentiality|ip|warranty|governing_law|force_majeure|non_compete|other)",
                    "title": "clause title",
                    "text": "full clause text",
                    "summary": "plain English summary",
                    "obligations": ["list of obligations"],
                    "rights": ["list of rights"]
                }]"""},
                {"role": "user", "content": text[:8000]},
            ],
            temperature=0.0,
        )
        try:
            return json.loads(response.choices[0].message.content)
        except:
            return []

    def extract_obligations(self, clauses: List[Dict]) -> List[Dict]:
        obligations = []
        for clause in clauses:
            for obs in clause.get("obligations", []):
                obligations.append({
                    "clause_type": clause["clause_type"],
                    "obligation": obs,
                    "text": clause["text"][:200],
                })
        return obligations

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

class RiskScorer:
    RISK_RULES = {
        "indemnity": {"base": 7, "keywords": ["unlimited", "gross negligence", "willful misconduct"]},
        "limitation": {"base": 4, "keywords": ["no limitation", "uncapped", "unlimited liability"]},
        "termination": {"base": 3, "keywords": ["immediate", "without cause", "convenience"]},
        "confidentiality": {"base": 5, "keywords": ["perpetual", "indefinite", "no exceptions"]},
        "ip": {"base": 6, "keywords": ["work for hire", "all rights", "exclusive"]},
        "warranty": {"base": 5, "keywords": ["as is", "no warranty", "disclaims all"]},
        "governing_law": {"base": 3, "keywords": ["arbitration", "waive jury", "exclusive jurisdiction"]},
        "non_compete": {"base": 7, "keywords": ["perpetual", "worldwide", "unlimited scope"]},
    }

    def score_clause(self, clause: Dict) -> Dict:
        clause_type = clause.get("clause_type", "other")
        text = clause.get("text", "").lower()
        rule = self.RISK_RULES.get(clause_type, {"base": 3, "keywords": []})
        score = rule["base"]
        risk_factors = []
        for keyword in rule["keywords"]:
            if keyword in text:
                score += 1
                risk_factors.append(f"Contains '{keyword}'")
        score = min(score, 10)
        return {
            "clause_type": clause_type,
            "risk_score": score,
            "risk_level": self._level(score),
            "risk_factors": risk_factors,
        }

    def _level(self, score: int) -> str:
        if score >= 8:
            return "HIGH"
        elif score >= 5:
            return "MEDIUM"
        return "LOW"

    def score_contract(self, clauses: List[Dict]) -> Dict:
        scored = [self.score_clause(c) for c in clauses]
        avg_score = sum(s["risk_score"] for s in scored) / len(scored) if scored else 0
        high_risk = [s for s in scored if s["risk_level"] == "HIGH"]
        return {
            "overall_risk_score": round(avg_score, 2),
            "overall_risk_level": self._level(int(avg_score)),
            "high_risk_clauses": high_risk,
            "all_scores": scored,
            "total_clauses": len(scored),
        }

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

class ComplianceChecker:
    def __init__(self, model: str = "gpt-4-turbo-preview"):
        self.client = OpenAI()
        self.model = model

    def check_compliance(
        self, text: str, standards: List[str]
    ) -> Dict:
        response = self.client.chat.completions.create(
            model=self.model,
            messages=[
                {"role": "system", "content": f"""Check this contract against standards: {', '.join(standards)}.
                Return JSON:
                {{
                    "compliant": true/false,
                    "issues": [{{"standard": "...", "issue": "...", "severity": "high|medium|low"}}],
                    "recommendations": ["list of recommendations"]
                }}"""},
                {"role": "user", "content": text[:8000]},
            ],
            temperature=0.0,
        )
        try:
            return json.loads(response.choices[0].message.content)
        except:
            return {"compliant": False, "issues": [], "recommendations": []}

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

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

    def analyze(self, file_path: str, standards: list = None) -> Dict:
        doc = self.parse(file_path)
        clauses = self.extractor.extract_clauses(doc["text"])
        risk = self.risk_scorer.score_contract(clauses)
        obligations = self.extractor.extract_obligations(clauses)
        compliance = None
        if standards:
            compliance = self.compliance_checker.check_compliance(doc["text"], standards)
        return {
            "source": file_path,
            "pages": doc.get("pages", 0),
            "total_clauses": len(clauses),
            "clauses": clauses,
            "risk_assessment": risk,
            "obligations": obligations,
            "compliance": compliance,
        }

    def compare(self, file1: str, file2: str) -> Dict:
        analysis1 = self.analyze(file1)
        analysis2 = self.analyze(file2)
        return {
            "contract_1": {"file": file1, "risk": analysis1["risk_assessment"]["overall_risk_score"]},
            "contract_2": {"file": file2, "risk": analysis2["risk_assessment"]["overall_risk_score"]},
            "clause_counts": {file1: analysis1["total_clauses"], file2: analysis2["total_clauses"]},
        }

import pytest
from document.parser import DocumentParser
from analysis.risk_scorer import RiskScorer

def test_parser():
    parser = DocumentParser()
    result = parser.parse("test_contract.pdf")
    assert "text" in result

def test_risk_scorer():
    scorer = RiskScorer()
    clause = {"clause_type": "indemnity", "text": "Unlimited indemnification for all claims"}
    result = scorer.score_clause(clause)
    assert result["risk_level"] == "HIGH"

# main.py
from agent import ContractAnalysisAgent
import json

def main():
    agent = ContractAnalysisAgent()
    file_path = input("Contract file path: ").strip()
    result = agent.analyze(file_path)
    print(f"\nClauses: {result['total_clauses']}")
    print(f"Risk Level: {result['risk_assessment']['overall_risk_level']}")
    print(f"Score: {result['risk_assessment']['overall_risk_score']}/10")
    if result["risk_assessment"]["high_risk_clauses"]:
        print("\nHIGH RISK CLAUSES:")
        for clause in result["risk_assessment"]["high_risk_clauses"]:
            print(f"  - {clause['clause_type']}: {clause['risk_factors']}")

if __name__ == "__main__":
    main()