# Create a virtual environment
python -m venv venv
source venv/bin/activate  # On Windows use: venv\Scripts\activate

# Install required libraries
pip install openai python-dotenv pydantic fastapi uvicorn

# Initialize project
npm init -y

# Install dependencies
npm install openai dotenv zod express
npm install --save-dev typescript @types/node @types/express ts-node

import os
from typing import Dict
from openai import OpenAI
from dotenv import load_dotenv
from pydantic import BaseModel, Field

# Load environment variables
load_dotenv()

# Initialize Client
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

class ListingAnalysis(BaseModel):
    """Schema for the processed listing."""
    original_text: str
    is_ai_generated: bool = Field(description="True if the text shows signs of AI generation")
    confidence_score: float = Field(description="0.0 to 1.0 score of AI probability")
    disclosure_notice: str = Field(description="The mandatory NYC legal disclaimer")

def analyze_listing(description: str) -> ListingAnalysis:
    """
    Analyzes a property description to determine if AI was used.
    """
    try:
        prompt = (
            "Analyze the following real estate listing. Determine if it was likely "
            "written by an AI. Return ONLY a JSON object with: "
            "'is_ai_generated' (boolean), 'confidence_score' (float), and "
            "'disclosure_notice' (string). "
            "If AI is detected, the notice should be: 'This listing was generated with AI assistance.'"
        )

        response = client.chat.completions.create(
            model="gpt-4o-mini", # Using a cost-effective model for classification
            messages=[
                {"role": "system", "content": "You are a compliance officer for NYC real estate."},
                {"role": "user", "content": f"{prompt}\n\nListing: {description}"}
            ],
            response_format={"type": "json_object"}
        )

        # Parse the JSON response
        import json
        data = json.loads(response.choices[0].message.content)
        
        return ListingAnalysis(
            original_text=description,
            is_ai_generated=data['is_ai_generated'],
            confidence_score=data['confidence_score'],
            disclosure_notice=data.get('disclosure_notice', "")
        )

    except Exception as e:
        print(f"Error during analysis: {e}")
        # Fallback: Default to safe (disclose if unsure)
        return ListingAnalysis(
            original_text=description,
            is_ai_generated=True, 
            confidence_score=0.0,
            disclosure_notice="Compliance Error: Manual review required."
        )

# --- Test Execution ---
if __name__ == "__main__":
    test_desc = "Experience luxury living in this stunning penthouse with floor-to-ceiling windows..."
    result = analyze_listing(test_desc)
    print(f"AI Detected: {result.is_ai_generated}")
    print(f"Notice: {result.disclosure_notice}")

import OpenAI from 'openai';
import 'dotenv/config';
import { z } from 'zod';

// 1. Define the Schema for strict compliance
const ListingSchema = z.object({
  isAiGenerated: z.boolean(),
  confidenceScore: z.number().min(0).max(1),
  disclosureNotice: z.string(),
});

type ListingResult = z.infer<typeof ListingSchema>;

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

/**
 * Analyzes property text for AI markers to comply with NYC regulations.
 * @param description The raw text from the real estate listing.
 */
async function processListingCompliance(description: string): Promise<ListingResult | null> {
  try {
    const response = await openai.chat.completions.create({
      model: "gpt-4o-mini",
      messages: [
        { 
          role: "system", 
          content: "You are a regulatory compliance tool. Analyze text for AI markers." 
        },
        { 
          role: "user", 
          content: `Analyze this listing: "${description}". Return JSON: { "isAiGenerated": boolean, "confidenceScore": number, "disclosureNotice": string }. If AI is suspected, use: 'AI-generated content detected.'` 
        }
      ],
      response_format: { type: "json_object" },
    });

    const rawContent = response.choices[0].message.content;
    if (!rawContent) throw new Error("Empty response from AI");

    // 2. Validate the AI output against our schema
    const parsed = JSON.parse(rawContent);
    return ListingSchema.parse(parsed);

  } catch (error) {
    console.error("Compliance Check Failed:", error);
    // 3. Fail-safe: If error occurs, we flag for manual review to avoid legal risk
    return {
      isAiGenerated: true,
      confidenceScore: 0,
      disclosureNotice: "Manual Review Required (System Error)"
    };
  }
}

// --- Test Execution ---
const sampleListing = "This breathtaking apartment offers unparalleled views of the skyline...";
processListingCompliance(sampleListing).then(console.log);

# API Keys
OPENAI_API_KEY=sk-proj-your-actual-key-here

# Environment Settings
NODE_ENV=development
PYTHON_ENV=dev

# Compliance Thresholds
# If confidence > 0.7, auto-apply disclosure
AI_DETECTION_THRESHOLD=0.7