1version: '3.8'
2services:
3  lakefs:
4    image: treeverse/lakefs:latest
5    ports:
6      - "8000:8000"
7    environment:
8      - LAKEFS_AUTH_ENCRYPT_SECRET_KEY=your-secret-key
9      - LAKEFS_DATABASE_TYPE=postgres
10      - LAKEFS_DATABASE_POSTGRES_CONNECTION_STRING=postgres://lakefs:lakefs@postgres:5432/lakefs?sslmode=disable
11      - LAKEFS_BLOCKSTORE_TYPE=s3
12      - LAKEFS_BLOCKSTORE_S3_REGION=us-east-1
13      - LAKEFS_BLOCKSTORE_S3_CREDENTIALS_ACCESS_KEY_ID=${AWS_ACCESS_KEY_ID}
14      - LAKEFS_BLOCKSTORE_S3_CREDENTIALS_SECRET_ACCESS_KEY=${AWS_SECRET_ACCESS_KEY}
15    depends_on:
16      - postgres
17    volumes:
18      - ./config/lakefs.yaml:/etc/lakefs.yaml
19
20  postgres:
21    image: postgres:13
22    environment:
23      POSTGRES_USER: lakefs
24      POSTGRES_PASSWORD: lakefs
25      POSTGRES_DB: lakefs
26    volumes:
27      - postgres_data:/var/lib/postgresql/data
28
29volumes:
30  postgres_data:

1# config/lakefs.yaml
2database:
3  type: postgres
4  postgres:
5    connection_string: postgres://lakefs:lakefs@postgres:5432/lakefs?sslmode=disable
6
7blockstore:
8  type: s3
9  s3:
10    region: us-east-1
11    profile: default
12
13auth:
14  encrypt:
15    secret_key: "your-secret-key-here"
16
17logging:
18  level: INFO
19  output: "-"
20
21actions:
22  enabled: true

1# branch_policies.py
2from lakefs import LakeFS
3import json
4
5def setup_branch_protection():
6    """Configure branch protection for legal repository"""
7
8    client = LakeFS(
9        host='http://localhost:8000',
10        username='admin',
11        password='admin'
12    )
13
14    # Main branch protection
15    main_protection = {
16        "pattern": "main",
17        "protection_rules": [
18            {
19                "type": "pre_merge_hook",
20                "hook_id": "legal_compliance_check"
21            },
22            {
23                "type": "pre_merge_hook",
24                "hook_id": "conflict_detection"
25            },
26            {
27                "type": "required_reviews",
28                "count": 2,
29                "required_reviewers": ["legal-team", "compliance-team"]
30            },
31            {
32                "type": "prevent_force_push",
33                "enabled": True
34            }
35        ]
36    }
37
38    # Review branch naming convention
39    review_branch_pattern = {
40        "pattern": "review/*",
41        "protection_rules": [
42            {
43                "type": "pre_commit_hook",
44                "hook_id": "document_validation"
45            },
46            {
47                "type": "pre_commit_hook",
48                "hook_id": "metadata_generation"
49            }
50        ]
51    }
52
53    client.create_branch_protection_rule(
54        repository='legal-contracts',
55        rules=[main_protection, review_branch_pattern]
56    )

1# metadata_generator.py
2import hashlib
3import json
4from datetime import datetime
5from typing import Dict, Any
6
7class DocumentVersioning:
8    def __init__(self, lakefs_client):
9        self.client = lakefs_client
10
11    def generate_document_metadata(self, file_path: str, content: bytes) -> Dict[str, Any]:
12        """Generate comprehensive metadata for legal documents"""
13
14        # Content hash for integrity
15        content_hash = hashlib.sha256(content).hexdigest()
16
17        # Extract document properties (simplified)
18        doc_type = self._detect_document_type(file_path)
19        word_count = self._count_words(content)
20
21        metadata = {
22            "document_id": f"{doc_type}_{content_hash[:8]}",
23            "file_path": file_path,
24            "content_hash": content_hash,
25            "document_type": doc_type,
26            "word_count": word_count,
27            "created_at": datetime.utcnow().isoformat(),
28            "lakefs_metadata": {
29                "repository": "legal-contracts",
30                "branch": self.client.get_current_branch(),
31                "commit_id": None,  # Set after commit
32                "version": self._get_version_number(file_path)
33            },
34            "legal_metadata": {
35                "requires_legal_review": self._requires_legal_review(doc_type),
36                "compliance_tags": self._get_compliance_tags(content),
37                "risk_level": self._assess_risk_level(content),
38                "expiration_tracking": self._extract_dates(content)
39            }
40        }
41
42        return metadata
43
44    def _detect_document_type(self, file_path: str) -> str:
45        """Detect document type from path and content"""
46        path_lower = file_path.lower()
47
48        if 'vendor' in path_lower or 'supplier' in path_lower:
49            return 'vendor_agreement'
50        elif 'employment' in path_lower or 'hire' in path_lower:
51            return 'employment_contract'
52        elif 'partnership' in path_lower or 'partner' in path_lower:
53            return 'partnership_agreement'
54        elif 'nda' in path_lower or 'confidential' in path_lower:
55            return 'nda'
56        else:
57            return 'general_contract'
58
59    def _requires_legal_review(self, doc_type: str) -> bool:
60        """Determine if document type requires legal team review"""
61        high_risk_types = {
62            'vendor_agreement',
63            'partnership_agreement',
64            'employment_contract'
65        }
66        return doc_type in high_risk_types
67
68    def _get_compliance_tags(self, content: bytes) -> list:
69        """Extract compliance requirements from document content"""
70        # Simplified compliance detection
71        content_text = content.decode('utf-8', errors='ignore').lower()
72
73        tags = []
74        if 'gdpr' in content_text or 'data protection' in content_text:
75            tags.append('gdpr_required')
76        if 'sox' in content_text or 'sarbanes' in content_text:
77            tags.append('sox_compliance')
78        if 'hipaa' in content_text:
79            tags.append('hipaa_required')
80        if 'pci' in content_text:
81            tags.append('pci_compliance')
82
83        return tags

1# hooks/legal_compliance_check.py
2import json
3import re
4from typing import Dict, List, Tuple
5
6class LegalComplianceHook:
7    def __init__(self):
8        self.required_clauses = {
9            'vendor_agreement': [
10                'limitation of liability',
11                'intellectual property',
12                'termination clause',
13                'governing law'
14            ],
15            'employment_contract': [
16                'at-will employment',
17                'confidentiality',
18                'intellectual property assignment',
19                'termination conditions'
20            ],
21            'partnership_agreement': [
22                'profit sharing',
23                'decision making authority',
24                'dissolution terms',
25                'intellectual property rights'
26            ]
27        }
28
29        self.prohibited_terms = [
30            'unlimited liability',
31            'perpetual agreement',
32            'automatic renewal without notice',
33            'non-compete beyond legal limits'
34        ]
35
36    def validate_pre_merge(self, changed_files: List[str]) -> Tuple[bool, List[str]]:
37        """
38        Validate legal documents before merge to main branch
39        Returns: (is_valid, list_of_issues)
40        """
41        issues = []
42
43        for file_path in changed_files:
44            if not self._is_legal_document(file_path):
45                continue
46
47            # Read document content
48            content = self._read_file_content(file_path)
49            metadata = self._read_metadata(file_path)
50
51            # Validate required clauses
52            clause_issues = self._validate_required_clauses(content, metadata.get('document_type'))
53            issues.extend(clause_issues)
54
55            # Check for prohibited terms
56            prohibition_issues = self._check_prohibited_terms(content)
57            issues.extend(prohibition_issues)
58
59            # Validate metadata completeness
60            metadata_issues = self._validate_metadata(metadata)
61            issues.extend(metadata_issues)
62
63        return len(issues) == 0, issues
64
65    def _validate_required_clauses(self, content: str, doc_type: str) -> List[str]:
66        """Check if document contains required legal clauses"""
67        issues = []
68        required = self.required_clauses.get(doc_type, [])
69
70        content_lower = content.lower()
71        for clause in required:
72            if clause not in content_lower:
73                issues.append(f"Missing required clause: '{clause}' for {doc_type}")
74
75        return issues
76
77    def _check_prohibited_terms(self, content: str) -> List[str]:
78        """Check for legally problematic terms"""
79        issues = []
80        content_lower = content.lower()
81
82        for term in self.prohibited_terms:
83            if term in content_lower:
84                issues.append(f"Prohibited term found: '{term}'")
85
86        return issues
87
88    def _validate_metadata(self, metadata: Dict) -> List[str]:
89        """Validate metadata completeness"""
90        issues = []
91        required_fields = [
92            'document_id',
93            'document_type',
94            'created_at',
95            'legal_metadata.risk_level',
96            'legal_metadata.requires_legal_review'
97        ]
98
99        for field in required_fields:
100            if '.' in field:
101                # Nested field check
102                parts = field.split('.')
103                current = metadata
104                for part in parts:
105                    if part not in current:
106                        issues.append(f"Missing required metadata field: {field}")
107                        break
108                    current = current[part]
109            else:
110                if field not in metadata:
111                    issues.append(f"Missing required metadata field: {field}")
112
113        return issues
114
115# Hook registration
116def pre_merge_hook(event_data):
117    """LakeFS pre-merge hook entry point"""
118    hook = LegalComplianceHook()
119
120    # Extract changed files from LakeFS event
121    changed_files = event_data.get('changed_files', [])
122
123    # Run validation
124    is_valid, issues = hook.validate_pre_merge(changed_files)
125
126    if not is_valid:
127        return {
128            'status': 'failed',
129            'message': 'Legal compliance check failed',
130            'details': issues
131        }
132
133    return {
134        'status': 'passed',
135        'message': 'Legal compliance check passed'
136    }

1# agents/legal_workflow_orchestrator.py
2from typing import Dict, List
3import asyncio
4from lakefs import LakeFS
5
6class LegalWorkflowOrchestrator:
7    def __init__(self, lakefs_client: LakeFS):
8        self.client = lakefs_client
9        self.agents = {
10            'document_analyzer': DocumentAnalysisAgent(),
11            'compliance_checker': ComplianceAgent(),
12            'risk_assessor': RiskAssessmentAgent(),
13            'version_manager': VersionManagementAgent()
14        }
15
16    async def process_contract_review(self, contract_path: str, review_requirements: Dict) -> Dict:
17        """Orchestrate multi-agent contract review workflow"""
18
19        # Create review branch
20        review_branch = f"review/contract-{self._generate_review_id()}"
21        self.client.create_branch(
22            repository='legal-contracts',
23            name=review_branch,
24            source='main'
25        )
26
27        try:
28            # Switch to review branch
29            self.client.checkout(repository='legal-contracts', ref=review_branch)
30
31            # Parallel agent analysis
32            tasks = []
33
34            # Document analysis
35            tasks.append(
36                self.agents['document_analyzer'].analyze_contract(contract_path)
37            )
38
39            # Compliance verification
40            tasks.append(
41                self.agents['compliance_checker'].check_compliance(
42                    contract_path,
43                    review_requirements.get('compliance_standards', [])
44                )
45            )
46
47            # Risk assessment
48            tasks.append(
49                self.agents['risk_assessor'].assess_risk(
50                    contract_path,
51                    review_requirements.get('risk_tolerance', 'medium')
52                )
53            )
54
55            # Version management
56            tasks.append(
57                self.agents['version_manager'].prepare_versioning(contract_path)
58            )
59
60            # Wait for all agents to complete
61            analysis_results, compliance_results, risk_results, version_results = await asyncio.gather(*tasks)
62
63            # Aggregate results
64            review_summary = self._aggregate_results(
65                analysis_results,
66                compliance_results,
67                risk_results,
68                version_results
69            )
70
71            # Generate review artifacts
72            await self._generate_review_artifacts(review_branch, review_summary)
73
74            # Create merge request if all checks pass
75            if review_summary['overall_status'] == 'approved':
76                merge_request = self._create_merge_request(review_branch, review_summary)
77                return {
78                    'status': 'ready_for_merge',
79                    'branch': review_branch,
80                    'merge_request': merge_request,
81                    'summary': review_summary
82                }
83            else:
84                return {
85                    'status': 'requires_revision',
86                    'branch': review_branch,
87                    'summary': review_summary,
88                    'required_actions': review_summary['required_actions']
89                }
90
91        except Exception as e:
92            # Cleanup on failure
93            self.client.delete_branch(repository='legal-contracts', name=review_branch)
94            raise e
95
96    def _aggregate_results(self, analysis, compliance, risk, version) -> Dict:
97        """Aggregate multi-agent results into review summary"""
98
99        # Determine overall status
100        all_checks = [
101            analysis.get('status') == 'passed',
102            compliance.get('status') == 'passed',
103            risk.get('risk_level') in ['low', 'medium'],
104            version.get('status') == 'ready'
105        ]
106
107        overall_status = 'approved' if all(all_checks) else 'requires_revision'
108
109        # Collect required actions
110        required_actions = []
111        if analysis.get('status') != 'passed':
112            required_actions.extend(analysis.get('required_changes', []))
113        if compliance.get('status') != 'passed':
114            required_actions.extend(compliance.get('violations', []))
115        if risk.get('risk_level') == 'high':
116            required_actions.append('High risk level requires executive approval')
117        if version.get('status') != 'ready':
118            required_actions.extend(version.get('issues', []))
119
120        return {
121            'overall_status': overall_status,
122            'analysis_summary': analysis,
123            'compliance_summary': compliance,
124            'risk_summary': risk,
125            'version_summary': version,
126            'required_actions': required_actions,
127            'review_timestamp': datetime.utcnow().isoformat()
128        }

1# merge_automation.py
2class MergeAutomation:
3    def __init__(self, lakefs_client):
4        self.client = lakefs_client
5
6    def setup_automated_merge_policies(self):
7        """Configure automated merge policies based on review outcomes"""
8
9        # Low-risk document auto-merge
10        low_risk_policy = {
11            "conditions": {
12                "risk_level": ["low"],
13                "compliance_status": "passed",
14                "required_approvals_met": True,
15                "no_conflicts": True
16            },
17            "actions": {
18                "auto_merge": True,
19                "notification_channels": ["slack", "email"],
20                "post_merge_hooks": ["audit_log", "backup_creation"]
21            }
22        }
23
24        # Medium-risk document approval workflow
25        medium_risk_policy = {
26            "conditions": {
27                "risk_level": ["medium"],
28                "compliance_status": "passed",
29                "legal_team_approval": True,
30                "business_owner_approval": True
31            },
32            "actions": {
33                "auto_merge": True,
34                "notification_channels": ["slack", "email", "legal_team"],
35                "post_merge_hooks": ["audit_log", "backup_creation", "compliance_report"]
36            }
37        }
38
39        # High-risk document manual review
40        high_risk_policy = {
41            "conditions": {
42                "risk_level": ["high"],
43                "compliance_status": "passed",
44                "executive_approval": True,
45                "legal_counsel_approval": True,
46                "business_impact_assessment": "completed"
47            },
48            "actions": {
49                "auto_merge": False,
50                "require_manual_merge": True,
51                "notification_channels": ["slack", "email", "legal_team", "executive_team"]
52            }
53        }
54
55        return [low_risk_policy, medium_risk_policy, high_risk_policy]

1# audit_logging.py
2import json
3from datetime import datetime
4from typing import Dict, Any
5
6class AuditLogger:
7    def __init__(self, lakefs_client):
8        self.client = lakefs_client
9
10    def log_document_action(self, action_type: str, document_path: str, metadata: Dict[str, Any]):
11        """Log all document actions for compliance audit trails"""
12
13        audit_entry = {
14            "timestamp": datetime.utcnow().isoformat(),
15            "action_type": action_type,  # create, modify, review, approve, merge, archive
16            "document_path": document_path,
17            "document_metadata": metadata,
18            "lakefs_context": {
19                "repository": self.client.get_current_repository(),
20                "branch": self.client.get_current_branch(),
21                "commit_id": self.client.get_head_commit(),
22                "user": self.client.get_current_user()
23            },
24            "compliance_context": {
25                "review_required": metadata.get('legal_metadata', {}).get('requires_legal_review', False),
26                "compliance_tags": metadata.get('legal_metadata', {}).get('compliance_tags', []),
27                "risk_level": metadata.get('legal_metadata', {}).get('risk_level', 'unknown')
28            }
29        }
30
31        # Store in audit branch
32        audit_file_path = f"audit/{datetime.utcnow().year}/{datetime.utcnow().month}/{action_type}_{datetime.utcnow().timestamp()}.json"
33
34        self._write_audit_file(audit_file_path, audit_entry)
35
36    def _write_audit_file(self, path: str, content: Dict):
37        """Write audit entry to LakeFS audit branch"""
38        # Switch to audit branch (create if doesn't exist)
39        try:
40            self.client.checkout(repository='legal-contracts', ref='audit')
41        except:
42            self.client.create_branch(repository='legal-contracts', name='audit', source='main')
43            self.client.checkout(repository='legal-contracts', ref='audit')
44
45        # Write audit file
46        self.client.upload_object(
47            repository='legal-contracts',
48            branch='audit',
49            path=path,
50            content=json.dumps(content, indent=2).encode()
51        )
52
53        # Commit audit entry
54        self.client.commit(
55            repository='legal-contracts',
56            branch='audit',
57            message=f"Audit log: {content['action_type']} for {content['document_path']}"
58        )

1# performance_optimizations.py
2import asyncio
3from concurrent.futures import ThreadPoolExecutor
4from typing import List, Dict
5
6class PerformanceOptimizer:
7    def __init__(self, lakefs_client, max_workers=10):
8        self.client = lakefs_client
9        self.executor = ThreadPoolExecutor(max_workers=max_workers)
10
11    async def batch_process_documents(self, document_paths: List[str]) -> Dict:
12        """Process multiple documents concurrently"""
13
14        # Create concurrent processing tasks
15        tasks = []
16        for doc_path in document_paths:
17            task = asyncio.create_task(
18                self._process_single_document(doc_path)
19            )
20            tasks.append(task)
21
22        # Wait for all documents to process
23        results = await asyncio.gather(*tasks, return_exceptions=True)
24
25        # Aggregate results
26        successful = []
27        failed = []
28
29        for i, result in enumerate(results):
30            if isinstance(result, Exception):
31                failed.append({
32                    'document': document_paths[i],
33                    'error': str(result)
34                })
35            else:
36                successful.append({
37                    'document': document_paths[i],
38                    'result': result
39                })
40
41        return {
42            'successful': successful,
43            'failed': failed,
44            'total_processed': len(document_paths),
45            'success_rate': len(successful) / len(document_paths)
46        }
47
48    async def _process_single_document(self, doc_path: str) -> Dict:
49        """Process a single document with all validations"""
50
51        # Run in thread pool to avoid blocking
52        loop = asyncio.get_event_loop()
53
54        # Document analysis
55        analysis_task = loop.run_in_executor(
56            self.executor,
57            self._analyze_document_content,
58            doc_path
59        )
60
61        # Metadata generation
62        metadata_task = loop.run_in_executor(
63            self.executor,
64            self._generate_document_metadata,
65            doc_path
66        )
67
68        # Compliance check
69        compliance_task = loop.run_in_executor(
70            self.executor,
71            self._run_compliance_checks,
72            doc_path
73        )
74
75        # Wait for all tasks
76        analysis, metadata, compliance = await asyncio.gather(
77            analysis_task, metadata_task, compliance_task
78        )
79
80        return {
81            'analysis': analysis,
82            'metadata': metadata,
83            'compliance': compliance,
84            'processing_timestamp': datetime.utcnow().isoformat()
85        }

1# k8s/lakefs-deployment.yaml
2apiVersion: apps/v1
3kind: Deployment
4metadata:
5  name: lakefs-legal
6  namespace: legal-infrastructure
7spec:
8  replicas: 3
9  selector:
10    matchLabels:
11      app: lakefs-legal
12  template:
13    metadata:
14      labels:
15        app: lakefs-legal
16    spec:
17      containers:
18      - name: lakefs
19        image: treeverse/lakefs:latest
20        ports:
21        - containerPort: 8000
22        env:
23        - name: LAKEFS_DATABASE_POSTGRES_CONNECTION_STRING
24          valueFrom:
25            secretKeyRef:
26              name: lakefs-secrets
27              key: database-url
28        - name: LAKEFS_BLOCKSTORE_S3_CREDENTIALS_ACCESS_KEY_ID
29          valueFrom:
30            secretKeyRef:
31              name: aws-credentials
32              key: access-key-id
33        - name: LAKEFS_BLOCKSTORE_S3_CREDENTIALS_SECRET_ACCESS_KEY
34          valueFrom:
35            secretKeyRef:
36              name: aws-credentials
37              key: secret-access-key
38        resources:
39          requests:
40            memory: "1Gi"
41            cpu: "500m"
42          limits:
43            memory: "2Gi"
44            cpu: "1000m"
45        livenessProbe:
46          httpGet:
47            path: /api/v1/healthcheck
48            port: 8000
49          initialDelaySeconds: 30
50          periodSeconds: 10
51        readinessProbe:
52          httpGet:
53            path: /api/v1/healthcheck
54            port: 8000
55          initialDelaySeconds: 5
56          periodSeconds: 5
57
58---
59apiVersion: v1
60kind: Service
61metadata:
62  name: lakefs-service
63  namespace: legal-infrastructure
64spec:
65  selector:
66    app: lakefs-legal
67  ports:
68  - protocol: TCP
69    port: 80
70    targetPort: 8000
71  type: ClusterIP

1# monitoring/lakefs-monitoring.yaml
2apiVersion: monitoring.coreos.com/v1
3kind: ServiceMonitor
4metadata:
5  name: lakefs-legal-monitor
6  namespace: legal-infrastructure
7spec:
8  selector:
9    matchLabels:
10      app: lakefs-legal
11  endpoints:
12  - port: http
13    path: /api/v1/metrics
14    interval: 30s
15
16---
17apiVersion: monitoring.coreos.com/v1
18kind: PrometheusRule
19metadata:
20  name: lakefs-legal-alerts
21  namespace: legal-infrastructure
22spec:
23  groups:
24  - name: lakefs.legal.rules
25    rules:
26    - alert: LakeFSHighMemoryUsage
27      expr: container_memory_usage_bytes{pod=~"lakefs-legal-.*"} / container_spec_memory_limit_bytes > 0.8
28      for: 5m
29      labels:
30        severity: warning
31      annotations:
32        summary: "LakeFS Legal instance high memory usage"
33        description: "LakeFS legal instance {{ $labels.pod }} memory usage is above 80%"
34
35    - alert: LakeFSDocumentProcessingBacklog
36      expr: lakefs_pending_documents > 100
37      for: 10m
38      labels:
39        severity: critical
40      annotations:
41        summary: "LakeFS document processing backlog"
42        description: "LakeFS has {{ $value }} documents pending processing"

1# tests/test_legal_workflow_integration.py
2import pytest
3import asyncio
4from lakefs import LakeFS
5from agents.legal_workflow_orchestrator import LegalWorkflowOrchestrator
6
7class TestLegalWorkflowIntegration:
8
9    @pytest.fixture
10    async def setup_test_environment(self):
11        """Setup test LakeFS environment"""
12        client = LakeFS(
13            host='http://localhost:8000',
14            username='test-admin',
15            password='test-admin'
16        )
17
18        # Create test repository
19        client.create_repository(
20            name='test-legal-contracts',
21            storage_namespace='s3://test-legal-bucket/'
22        )
23
24        orchestrator = LegalWorkflowOrchestrator(client)
25
26        yield client, orchestrator
27
28        # Cleanup
29        client.delete_repository('test-legal-contracts')
30
31    @pytest.mark.asyncio
32    async def test_contract_review_workflow(self, setup_test_environment):
33        """Test end-to-end contract review workflow"""
34        client, orchestrator = setup_test_environment
35
36        # Upload test contract
37        test_contract_content = self._create_test_contract()
38        client.upload_object(
39            repository='test-legal-contracts',
40            branch='main',
41            path='contracts/test-vendor-agreement.docx',
42            content=test_contract_content
43        )
44
45        # Process contract review
46        result = await orchestrator.process_contract_review(
47            contract_path='contracts/test-vendor-agreement.docx',
48            review_requirements={
49                'compliance_standards': ['gdpr', 'sox'],
50                'risk_tolerance': 'medium'
51            }
52        )
53
54        # Verify results
55        assert result['status'] in ['ready_for_merge', 'requires_revision']
56        assert 'summary' in result
57        assert result['summary']['overall_status'] in ['approved', 'requires_revision']
58
59        # Verify branch creation
60        branches = client.list_branches('test-legal-contracts')
61        review_branches = [b for b in branches if b.startswith('review/')]
62        assert len(review_branches) == 1
63
64    @pytest.mark.asyncio
65    async def test_compliance_hook_validation(self, setup_test_environment):
66        """Test pre-merge compliance validation"""
67        client, orchestrator = setup_test_environment
68
69        # Create review branch
70        client.create_branch(
71            repository='test-legal-contracts',
72            name='review/test-compliance',
73            source='main'
74        )
75
76        # Upload contract with compliance issues
77        problematic_contract = self._create_contract_with_issues()
78        client.upload_object(
79            repository='test-legal-contracts',
80            branch='review/test-compliance',
81            path='contracts/problematic-contract.docx',
82            content=problematic_contract
83        )
84
85        # Attempt merge (should fail)
86        try:
87            client.merge(
88                repository='test-legal-contracts',
89                source_ref='review/test-compliance',
90                destination_branch='main'
91            )
92            assert False, "Merge should have failed due to compliance issues"
93        except Exception as e:
94            assert "Legal compliance check failed" in str(e)
95
96    def _create_test_contract(self) -> bytes:
97        """Create a valid test contract"""
98        contract_content = """
99        VENDOR AGREEMENT
100
101        This agreement includes:
102        - Limitation of liability clause
103        - Intellectual property rights
104        - Termination clause
105        - Governing law specification
106
107        GDPR compliance ensured.
108        """
109        return contract_content.encode()
110
111    def _create_contract_with_issues(self) -> bytes:
112        """Create a contract with compliance issues"""
113        problematic_content = """
114        PROBLEMATIC VENDOR AGREEMENT
115
116        This agreement has unlimited liability
117        and is a perpetual agreement.
118
119        No termination clause provided.
120        """
121        return problematic_content.encode()