Automated Contract Analysis and Clause Extraction

import { Mixpeek } from 'mixpeek';

const client = new Mixpeek({ apiKey: process.env.MIXPEEK_API_KEY });

// Index contract portfolio
await client.buckets.connect({
  collection_id: 'contracts',
  bucket_uri: 's3://legal/contracts/',
  extractors: [
    'document-parser',
    'clause-extraction',
    'entity-extraction',
    'table-extraction',
    'signature-detection'
  ],
  settings: {
    contract_types: ['nda', 'msa', 'sow', 'license', 'employment'],
    extract_fields: [
      'parties', 'effective_date', 'term', 'termination',
      'liability_cap', 'indemnification', 'governing_law',
      'payment_terms', 'ip_ownership', 'confidentiality'
    ],
    flag_non_standard: true
  }
});

// Analyze contract for key terms and risks
async function analyzeContract(contractUrl: string, contractType: string) {
  const analysis = await client.contracts.analyze({
    url: contractUrl,
    contract_type: contractType,
    compare_to_template: `templates/${contractType}-standard.pdf`,
    risk_checks: [
      'unlimited_liability',
      'broad_indemnification',
      'auto_renewal',
      'most_favored_nation',
      'assignment_restrictions',
      'audit_rights',
      'ip_assignment'
    ]
  });

  return {
    summary: analysis.summary,
    key_terms: {
      parties: analysis.parties,
      effective_date: analysis.effective_date,
      term: analysis.term,
      value: analysis.contract_value,
      liability_cap: analysis.liability_cap
    },
    risks_identified: analysis.risks,
    template_deviations: analysis.deviations,
    recommended_actions: analysis.recommendations
  };
}

// Search contract portfolio
async function searchContracts(query: string, filters?: {
  contract_types?: string[];
  date_range?: { start: string; end: string };
  parties?: string[];
  risk_level?: string;
}) {
  const results = await client.retrieve({
    collection_id: 'contracts',
    query: {
      type: 'text',
      text: query  // e.g., "liability cap less than 2x contract value"
    },
    filters: {
      contract_type: filters?.contract_types ? { $in: filters.contract_types } : undefined,
      effective_date: filters?.date_range ? {
        $gte: filters.date_range.start,
        $lte: filters.date_range.end
      } : undefined,
      risk_level: filters?.risk_level
    },
    return_fields: [
      'summary', 'parties', 'key_terms',
      'risks', 'contract_type', 'effective_date'
    ],
    limit: 100
  });

  return results;
}

// Generate contract review report
async function generateReviewReport(contractId: string) {
  const contract = await client.collections.get(contractId);

  const report = {
    executive_summary: {
      contract_type: contract.contract_type,
      parties: contract.parties,
      term: contract.term,
      value: contract.contract_value,
      overall_risk: contract.risk_level
    },

    key_terms_matrix: contract.key_terms,

    risk_analysis: contract.risks.map(r => ({
      risk: r.description,
      severity: r.severity,
      clause_reference: r.clause_location,
      recommendation: r.mitigation
    })),

    template_deviations: contract.deviations.map(d => ({
      clause: d.clause_type,
      template_text: d.template_version,
      actual_text: d.contract_version,
      impact: d.impact_assessment
    })),

    approval_recommendation: contract.recommendation
  };

  return report;
}