Automate Real Estate Listings 🚀

// Bulk Processing with Error Handling (50-500 listings/day)
import Anthropic from '@anthropic-ai/sdk';
import * as fs from 'fs';

interface PropertyData {
  raw_text: string;
  mls_number?: string;
}

interface ListingResult {
  mls_number: string;
  extracted: any;
  variations: any[];
  optimized: any;
  status: 'success' | 'failed';
  error?: string;
}

class ListingAutomation {
  private anthropic: Anthropic;
  private maxRetries = 3;
  private batchSize = 10;

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

  async processBatch(properties: PropertyData[]): Promise<ListingResult[]> {
    const results: ListingResult[] = [];

    // Process in batches to avoid rate limits
    for (let i = 0; i < properties.length; i += this.batchSize) {
      const batch = properties.slice(i, i + this.batchSize);
      const batchResults = await Promise.allSettled(
        batch.map((prop) => this.processProperty(prop))
      );

      batchResults.forEach((result, index) => {
        if (result.status === 'fulfilled') {
          results.push(result.value);
        } else {
          results.push({
            mls_number: batch[index].mls_number || 'unknown',
            extracted: {},
            variations: [],
            optimized: {},
            status: 'failed',
            error: result.reason.message,
          });
        }
      });

      // Rate limiting: wait between batches
      if (i + this.batchSize < properties.length) {
        await this.delay(2000);
      }
    }

    return results;
  }

  private async processProperty(property: PropertyData): Promise<ListingResult> {
    try {
      // Step 1: Extract with retry
      const extracted = await this.retryWithBackoff(async () => {
        const response = await this.anthropic.messages.create({
          model: 'claude-3-5-sonnet-20241022',
          max_tokens: 2048,
          messages: [
            {
              role: 'user',
              content: `Extract property details as JSON: ${property.raw_text}`,
            },
          ],
        });

        const content = response.content[0];
        if (content.type !== 'text') throw new Error('Invalid response');
        return JSON.parse(content.text);
      });

      // Step 2: Generate variations
      const variations = await this.retryWithBackoff(async () => {
        const response = await this.anthropic.messages.create({
          model: 'claude-3-5-sonnet-20241022',
          max_tokens: 3072,
          messages: [
            {
              role: 'user',
              content: `Generate 3 style variations (luxury, family, investor) for: ${JSON.stringify(extracted)}`,
            },
          ],
        });

        const content = response.content[0];
        if (content.type !== 'text') throw new Error('Invalid response');
        return JSON.parse(content.text);
      });

      // Step 3: Optimize for MLS
      const optimized = await this.retryWithBackoff(async () => {
        const response = await this.anthropic.messages.create({
          model: 'claude-3-5-sonnet-20241022',
          max_tokens: 1024,
          messages: [
            {
              role: 'user',
              content: `Optimize for MLS (300 char max): ${variations[0].description}`,
            },
          ],
        });

        const content = response.content[0];
        if (content.type !== 'text') throw new Error('Invalid response');
        return JSON.parse(content.text);
      });

      return {
        mls_number: extracted.mls_number || property.mls_number || 'unknown',
        extracted,
        variations,
        optimized,
        status: 'success',
      };
    } catch (error) {
      throw new Error(`Failed to process property: ${error}`);
    }
  }

  private async retryWithBackoff<T>(
    fn: () => Promise<T>,
    retries = this.maxRetries
  ): Promise<T> {
    let lastError: Error | null = null;

    for (let attempt = 0; attempt < retries; attempt++) {
      try {
        return await Promise.race([
          fn(),
          new Promise<never>((_, reject) =>
            setTimeout(() => reject(new Error('Timeout')), 45000)
          ),
        ]);
      } catch (error) {
        lastError = error as Error;
        if (attempt < retries - 1) {
          const backoff = Math.pow(2, attempt) * 1000;
          await this.delay(backoff);
        }
      }
    }

    throw lastError;
  }

  private delay(ms: number): Promise<void> {
    return new Promise((resolve) => setTimeout(resolve, ms));
  }

  async exportToCSV(results: ListingResult[], filename: string): Promise<void> {
    const csv = results.map((r) => ({
      mls_number: r.mls_number,
      status: r.status,
      bedrooms: r.extracted.bedrooms || '',
      price: r.extracted.price || '',
      luxury_headline: r.variations[0]?.headline || '',
      optimized_text: r.optimized.public_remarks || '',
      character_count: r.optimized.character_count || 0,
      error: r.error || '',
    }));

    const header = Object.keys(csv[0]).join(',');
    const rows = csv.map((row) => Object.values(row).join(','));
    const content = [header, ...rows].join('\n');

    fs.writeFileSync(filename, content);
  }
}

// Usage
const automation = new ListingAutomation();

const properties: PropertyData[] = [
  { raw_text: '3BR colonial, 2400sf, $749k, Boston MA', mls_number: '12345678' },
  { raw_text: '4BR ranch, 3200sf, $899k, Cambridge MA', mls_number: '87654321' },
  // ... load from CSV or database
];

const results = await automation.processBatch(properties);
const successCount = results.filter((r) => r.status === 'success').length;

console.log(`Processed ${results.length} listings`);
console.log(`Success: ${successCount}, Failed: ${results.length - successCount}`);

await automation.exportToCSV(results, 'listings_output.csv');