Build an AI Contract Analyzer

# Example prompt for Claude Code
Create a Next.js 14 project with TypeScript for a contract analyzer:
- App Router with /upload and /analysis/[id] routes
- Supabase client configuration
- API routes for /api/upload and /api/analyze
- Environment variable setup for ANTHROPIC_API_KEY and SUPABASE_URL
- Tailwind CSS with a dark theme
- File upload component with drag-and-drop

// components/ContractUploader.tsx
import { useCallback, useState } from 'react';
import { useDropzone } from 'react-dropzone';

interface ContractUploaderProps {
  onUpload: (file: File) => Promise<void>;
}

export function ContractUploader({ onUpload }: ContractUploaderProps) {
  const [uploading, setUploading] = useState(false);
  const [progress, setProgress] = useState(0);

  const onDrop = useCallback(async (acceptedFiles: File[]) => {
    const file = acceptedFiles[0];
    if (!file || file.type !== 'application/pdf') {
      alert('Please upload a PDF file');
      return;
    }

    setUploading(true);
    try {
      await onUpload(file);
    } finally {
      setUploading(false);
      setProgress(0);
    }
  }, [onUpload]);

  const { getRootProps, getInputProps, isDragActive } = useDropzone({
    onDrop,
    accept: { 'application/pdf': ['.pdf'] },
    maxFiles: 1,
    maxSize: 10 * 1024 * 1024, // 10MB limit
  });

  return (
    <div
      {...getRootProps()}
      className={`
        border-2 border-dashed rounded-xl p-12 text-center
        transition-colors cursor-pointer
        ${isDragActive ? 'border-blue-500 bg-blue-500/10' : 'border-gray-600 hover:border-gray-500'}
      `}
    >
      <input {...getInputProps()} />
      {uploading ? (
        <div className="space-y-4">
          <div className="animate-spin w-8 h-8 border-2 border-blue-500 border-t-transparent rounded-full mx-auto" />
          <p>Uploading... {progress}%</p>
        </div>
      ) : (
        <div className="space-y-4">
          <div className="text-4xl">📄</div>
          <p className="text-lg">
            {isDragActive ? 'Drop your contract here' : 'Drag & drop a PDF contract, or click to browse'}
          </p>
          <p className="text-sm text-gray-500">Maximum file size: 10MB</p>
        </div>
      )}
    </div>
  );
}

// lib/pdf-parser.ts
import pdf from 'pdf-parse';

export interface ParsedContract {
  text: string;
  pageCount: number;
  metadata: {
    title?: string;
    author?: string;
    creationDate?: string;
  };
}

export async function parseContractPDF(buffer: Buffer): Promise<ParsedContract> {
  const data = await pdf(buffer);

  return {
    text: data.text,
    pageCount: data.numpages,
    metadata: {
      title: data.info?.Title,
      author: data.info?.Author,
      creationDate: data.info?.CreationDate,
    },
  };
}

// API Route: /api/upload/route.ts
import { NextRequest, NextResponse } from 'next/server';
import { parseContractPDF } from '@/lib/pdf-parser';
import { createClient } from '@supabase/supabase-js';

export async function POST(request: NextRequest) {
  const formData = await request.formData();
  const file = formData.get('file') as File;

  if (!file) {
    return NextResponse.json({ error: 'No file provided' }, { status: 400 });
  }

  const buffer = Buffer.from(await file.arrayBuffer());
  const parsed = await parseContractPDF(buffer);

  // Store in Supabase
  const supabase = createClient(
    process.env.SUPABASE_URL!,
    process.env.SUPABASE_SERVICE_KEY!
  );

  // Upload PDF to storage
  const fileName = `contracts/${Date.now()}-${file.name}`;
  await supabase.storage.from('contracts').upload(fileName, buffer);

  // Save metadata to database
  const { data, error } = await supabase
    .from('contracts')
    .insert({
      filename: file.name,
      storage_path: fileName,
      page_count: parsed.pageCount,
      text_content: parsed.text,
      status: 'pending_analysis',
    })
    .select()
    .single();

  if (error) {
    return NextResponse.json({ error: error.message }, { status: 500 });
  }

  return NextResponse.json({ contractId: data.id, pageCount: parsed.pageCount });
}

// lib/chunker.ts
export interface DocumentChunk {
  index: number;
  content: string;
  startPage?: number;
  endPage?: number;
}

const MAX_CHUNK_SIZE = 100000; // ~25k tokens, safe for Claude
const OVERLAP_SIZE = 500; // Overlap to maintain context

export function chunkDocument(text: string): DocumentChunk[] {
  // If document fits in one chunk, return as-is
  if (text.length <= MAX_CHUNK_SIZE) {
    return [{ index: 0, content: text }];
  }

  const chunks: DocumentChunk[] = [];
  let currentPosition = 0;
  let chunkIndex = 0;

  while (currentPosition < text.length) {
    let endPosition = currentPosition + MAX_CHUNK_SIZE;

    // Try to break at paragraph or section boundary
    if (endPosition < text.length) {
      const breakPoints = [
        text.lastIndexOf('\n\n', endPosition),  // Paragraph break
        text.lastIndexOf('.\n', endPosition),   // Sentence + newline
        text.lastIndexOf('. ', endPosition),    // Sentence break
      ];

      const bestBreak = breakPoints
        .filter(bp => bp > currentPosition + MAX_CHUNK_SIZE * 0.5)
        .sort((a, b) => b - a)[0];

      if (bestBreak) {
        endPosition = bestBreak + 1;
      }
    }

    chunks.push({
      index: chunkIndex,
      content: text.slice(
        Math.max(0, currentPosition - (chunkIndex > 0 ? OVERLAP_SIZE : 0)),
        Math.min(text.length, endPosition)
      ),
    });

    currentPosition = endPosition;
    chunkIndex++;
  }

  return chunks;
}

// lib/contract-analyzer.ts
import Anthropic from '@anthropic-ai/sdk';
import { chunkDocument } from './chunker';

const anthropic = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
});

export interface ContractAnalysis {
  summary: string;
  clauses: ExtractedClause[];
  risks: IdentifiedRisk[];
  recommendations: string[];
}

export interface ExtractedClause {
  type: string;
  title: string;
  content: string;
  location: string;
}

export interface IdentifiedRisk {
  severity: 'high' | 'medium' | 'low';
  title: string;
  description: string;
  clauseReference: string;
  recommendation: string;
}

const LEGAL_ANALYSIS_PROMPT = `You are an expert legal analyst specializing in contract review.
Analyze the following contract text and provide a comprehensive analysis.

Your analysis must include:

1. **EXECUTIVE SUMMARY** (2-3 paragraphs)
   - Contract type and parties involved
   - Key terms and obligations
   - Overall assessment

2. **KEY CLAUSES** - Extract and categorize important clauses:
   - Indemnification clauses
   - Limitation of liability
   - Termination provisions
   - Confidentiality/NDA terms
   - Intellectual property rights
   - Payment terms
   - Governing law and jurisdiction
   - Force majeure
   - Assignment restrictions
   - Non-compete/non-solicitation

3. **RISK ANALYSIS** - Identify potential issues with severity ratings:
   - HIGH: Terms that could cause significant financial or legal exposure
   - MEDIUM: Terms that are unfavorable but manageable
   - LOW: Minor concerns or areas for negotiation

4. **RECOMMENDATIONS** - Actionable suggestions for:
   - Terms to negotiate or modify
   - Missing protections to add
   - Clarifications needed

Respond in valid JSON format matching this structure:
{
  "summary": "Executive summary text...",
  "clauses": [
    {
      "type": "indemnification",
      "title": "Clause title",
      "content": "Relevant clause text",
      "location": "Section X.X"
    }
  ],
  "risks": [
    {
      "severity": "high|medium|low",
      "title": "Risk title",
      "description": "Detailed description",
      "clauseReference": "Section X.X",
      "recommendation": "Suggested action"
    }
  ],
  "recommendations": ["Recommendation 1", "Recommendation 2"]
}

CONTRACT TEXT:
`;

export async function analyzeContract(contractText: string): Promise<ContractAnalysis> {
  const chunks = chunkDocument(contractText);

  if (chunks.length === 1) {
    // Single chunk - analyze directly
    return analyzeSingleChunk(chunks[0].content);
  }

  // Multiple chunks - analyze each, then synthesize
  const chunkAnalyses = await Promise.all(
    chunks.map(chunk => analyzeChunk(chunk.content, chunk.index, chunks.length))
  );

  return synthesizeAnalyses(chunkAnalyses);
}

async function analyzeSingleChunk(text: string): Promise<ContractAnalysis> {
  const response = await anthropic.messages.create({
    model: 'claude-3-opus-20240229',
    max_tokens: 4096,
    messages: [{
      role: 'user',
      content: LEGAL_ANALYSIS_PROMPT + text,
    }],
  });

  const content = response.content[0];
  if (content.type !== 'text') {
    throw new Error('Unexpected response type');
  }

  // Parse JSON from response
  const jsonMatch = content.text.match(/\{[\s\S]*\}/);
  if (!jsonMatch) {
    throw new Error('Failed to parse analysis response');
  }

  return JSON.parse(jsonMatch[0]);
}

// lib/contract-comparison.ts
import Anthropic from '@anthropic-ai/sdk';

const anthropic = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
});

export interface ContractDifference {
  clauseType: string;
  contractA: string | null;
  contractB: string | null;
  significance: 'critical' | 'important' | 'minor';
  analysis: string;
}

export interface ComparisonResult {
  summary: string;
  differences: ContractDifference[];
  missingInA: string[];
  missingInB: string[];
  recommendation: string;
}

const COMPARISON_PROMPT = `You are a legal contract analyst. Compare these two contracts
and identify all meaningful differences in terms, conditions, and protections.

Focus on:
1. Terms that differ between contracts
2. Clauses present in one but missing in the other
3. Variations in liability limits, indemnification, termination rights
4. Payment terms and conditions differences

Rate each difference as: critical, important, or minor.

CONTRACT A:
{contractA}

CONTRACT B:
{contractB}

Respond in JSON format:
{
  "summary": "Brief overview of key differences",
  "differences": [...],
  "missingInA": ["clauses in B but not A"],
  "missingInB": ["clauses in A but not B"],
  "recommendation": "Which contract is more favorable and why"
}`;

export async function compareContracts(
  contractA: string,
  contractB: string
): Promise<ComparisonResult> {
  const prompt = COMPARISON_PROMPT
    .replace('{contractA}', contractA)
    .replace('{contractB}', contractB);

  const response = await anthropic.messages.create({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 4096,
    messages: [{ role: 'user', content: prompt }],
  });

  const content = response.content[0];
  if (content.type !== 'text') {
    throw new Error('Unexpected response type');
  }

  const jsonMatch = content.text.match(/\{[\s\S]*\}/);
  return JSON.parse(jsonMatch![0]);
}

// components/AnalysisReport.tsx
import { ContractAnalysis, IdentifiedRisk } from '@/lib/contract-analyzer';

interface AnalysisReportProps {
  analysis: ContractAnalysis;
  contractName: string;
}

export function AnalysisReport({ analysis, contractName }: AnalysisReportProps) {
  const riskCounts = {
    high: analysis.risks.filter(r => r.severity === 'high').length,
    medium: analysis.risks.filter(r => r.severity === 'medium').length,
    low: analysis.risks.filter(r => r.severity === 'low').length,
  };

  return (
    <div className="space-y-8">
      {/* Header */}
      <div className="border-b border-gray-700 pb-6">
        <h1 className="text-2xl font-bold">Contract Analysis Report</h1>
        <p className="text-gray-400 mt-2">{contractName}</p>
        <p className="text-sm text-gray-500">Generated on {new Date().toLocaleDateString()}</p>
      </div>

      {/* Risk Overview */}
      <div className="grid grid-cols-3 gap-4">
        <RiskBadge count={riskCounts.high} severity="high" />
        <RiskBadge count={riskCounts.medium} severity="medium" />
        <RiskBadge count={riskCounts.low} severity="low" />
      </div>

      {/* Executive Summary */}
      <section>
        <h2 className="text-xl font-semibold mb-4">Executive Summary</h2>
        <div className="bg-gray-800 rounded-lg p-6">
          <p className="text-gray-300 whitespace-pre-wrap">{analysis.summary}</p>
        </div>
      </section>

      {/* Identified Risks */}
      <section>
        <h2 className="text-xl font-semibold mb-4">Identified Risks</h2>
        <div className="space-y-4">
          {analysis.risks.map((risk, index) => (
            <RiskCard key={index} risk={risk} />
          ))}
        </div>
      </section>

      {/* Key Clauses */}
      <section>
        <h2 className="text-xl font-semibold mb-4">Key Clauses</h2>
        <div className="space-y-4">
          {analysis.clauses.map((clause, index) => (
            <ClauseCard key={index} clause={clause} />
          ))}
        </div>
      </section>

      {/* Recommendations */}
      <section>
        <h2 className="text-xl font-semibold mb-4">Recommendations</h2>
        <ul className="space-y-2">
          {analysis.recommendations.map((rec, index) => (
            <li key={index} className="flex items-start gap-3">
              <span className="text-blue-400">→</span>
              <span className="text-gray-300">{rec}</span>
            </li>
          ))}
        </ul>
      </section>
    </div>
  );
}

function RiskBadge({ count, severity }: { count: number; severity: string }) {
  const colors = {
    high: 'bg-red-500/20 text-red-400 border-red-500/30',
    medium: 'bg-yellow-500/20 text-yellow-400 border-yellow-500/30',
    low: 'bg-green-500/20 text-green-400 border-green-500/30',
  };

  return (
    <div className={`rounded-lg border p-4 text-center ${colors[severity]}`}>
      <div className="text-3xl font-bold">{count}</div>
      <div className="text-sm capitalize">{severity} Risk</div>
    </div>
  );
}

function RiskCard({ risk }: { risk: IdentifiedRisk }) {
  const severityColors = {
    high: 'border-l-red-500',
    medium: 'border-l-yellow-500',
    low: 'border-l-green-500',
  };

  return (
    <div className={`bg-gray-800 rounded-lg p-4 border-l-4 ${severityColors[risk.severity]}`}>
      <div className="flex items-center justify-between mb-2">
        <h3 className="font-semibold">{risk.title}</h3>
        <span className="text-xs uppercase px-2 py-1 rounded bg-gray-700">
          {risk.severity}
        </span>
      </div>
      <p className="text-gray-400 text-sm mb-3">{risk.description}</p>
      <div className="text-xs text-gray-500 mb-2">{risk.clauseReference}</div>
      <div className="bg-blue-500/10 text-blue-400 text-sm p-2 rounded">
        💡 {risk.recommendation}
      </div>
    </div>
  );
}