chore: reapply local updates

scripts/deploy-to-hf.ts

@@ -0,0 +1,31 @@
+import { execSync } from 'child_process';
+import * as dotenv from 'dotenv';
+
+dotenv.config();
+
+async function deploy() {
+    console.log('🚀 Starting deployment to Hugging Face...');
+
+    try {
+        // Configure git
+        execSync('git config --global user.email "deploy@wbes.com"');
+        execSync('git config --global user.name "WBES Deploy"');
+
+        // Add Hugging Face remote if it doesn't exist
+        try {
+            execSync('git remote get-url hf');
+        } catch {
+            execSync('git remote add hf https://huggingface.co/spaces/wbes/executive-suites');
+        }
+
+        // Push to Hugging Face
+        execSync('git push hf main', { stdio: 'inherit' });
+        console.log('✅ Deployment successful!');
+
+    } catch (error) {
+        console.error('❌ Deployment failed:', error);
+        process.exit(1);
+    }
+}
+
+deploy(); 

scripts/e2e-test.ts

@@ -0,0 +1,94 @@
+import fetch from 'node-fetch';
+import * as dotenv from 'dotenv';
+
+dotenv.config();
+
+const API_URL = process.env.API_URL || 'http://localhost:3000';
+
+interface User {
+    id: string;
+    email: string;
+    name: string;
+}
+
+interface Conversation {
+    id: string;
+    userId: string;
+}
+
+async function e2eTest() {
+    console.log('🧪 Starting end-to-end tests...');
+
+    try {
+        // Health check
+        const healthResponse = await fetch(`${API_URL}/api/health`);
+        if (!healthResponse.ok) {
+            throw new Error('Health check failed');
+        }
+        console.log('✅ Health check passed');
+
+        // Test user creation
+        const userResponse = await fetch(`${API_URL}/api/users`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                email: 'test@example.com',
+                name: 'Test User'
+            })
+        });
+        if (!userResponse.ok) {
+            throw new Error('User creation failed');
+        }
+        const user = await userResponse.json() as User;
+        console.log('✅ User creation passed');
+
+        // Test conversation creation
+        const conversationResponse = await fetch(`${API_URL}/api/conversations`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                userId: user.id
+            })
+        });
+        if (!conversationResponse.ok) {
+            throw new Error('Conversation creation failed');
+        }
+        const conversation = await conversationResponse.json() as Conversation;
+        console.log('✅ Conversation creation passed');
+
+        // Test message creation
+        const messageResponse = await fetch(`${API_URL}/api/messages`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                conversationId: conversation.id,
+                sender: 'user',
+                content: 'Hello, world!'
+            })
+        });
+        if (!messageResponse.ok) {
+            throw new Error('Message creation failed');
+        }
+        console.log('✅ Message creation passed');
+
+        // Test RAG query
+        const ragResponse = await fetch(`${API_URL}/api/rag/query`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                query: 'What are your office hours?'
+            })
+        });
+        if (!ragResponse.ok) {
+            throw new Error('RAG query failed');
+        }
+        console.log('✅ RAG query passed');
+
+        console.log('✅ All end-to-end tests passed!');
+    } catch (error) {
+        console.error('❌ End-to-end test failed:', error);
+        process.exit(1);
+    }
+}
+
+e2eTest(); 

scripts/setup-hf-secrets.ts

@@ -0,0 +1,60 @@
+import fetch from 'node-fetch';
+import * as dotenv from 'dotenv';
+
+dotenv.config();
+
+const HF_TOKEN = process.env.HUGGINGFACE_TOKEN;
+const SPACE_ID = 'wbes/executive-suites';
+
+interface Secret {
+    key: string;
+    value: string;
+}
+
+async function setupSecrets() {
+    console.log('🔐 Setting up Hugging Face secrets...');
+
+    if (!HF_TOKEN) {
+        throw new Error('HUGGINGFACE_TOKEN not found in environment');
+    }
+
+    const secrets: Secret[] = [
+        { key: 'DATABASE_URL', value: process.env.DATABASE_URL || '' },
+        { key: 'NEXTAUTH_SECRET', value: process.env.NEXTAUTH_SECRET || '' },
+        { key: 'NEXTAUTH_URL', value: process.env.NEXTAUTH_URL || '' }
+    ];
+
+    try {
+        for (const secret of secrets) {
+            if (!secret.value) {
+                console.warn(`⚠️ Warning: ${secret.key} is empty`);
+                continue;
+            }
+
+            const response = await fetch(
+                `https://huggingface.co/api/spaces/${SPACE_ID}/secrets/${secret.key}`,
+                {
+                    method: 'PUT',
+                    headers: {
+                        'Authorization': `Bearer ${HF_TOKEN}`,
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({ value: secret.value })
+                }
+            );
+
+            if (!response.ok) {
+                throw new Error(`Failed to set ${secret.key}: ${response.statusText}`);
+            }
+
+            console.log(`✅ Set ${secret.key}`);
+        }
+
+        console.log('✅ All secrets configured successfully!');
+    } catch (error) {
+        console.error('❌ Failed to set secrets:', error);
+        process.exit(1);
+    }
+}
+
+setupSecrets(); 

scripts/smoke-test.ts

@@ -0,0 +1,51 @@
+import { PrismaClient } from '@prisma/client';
+import * as dotenv from 'dotenv';
+
+dotenv.config();
+
+const prisma = new PrismaClient();
+
+async function smokeTest() {
+    console.log('🧪 Starting smoke test...');
+
+    try {
+        // Test user
+        const user = await prisma.user.findFirst();
+        if (!user) {
+            throw new Error('User not found');
+        }
+        console.log('✅ User verified:', user.email);
+
+        // Test session
+        const session = await prisma.session.findFirst();
+        if (!session) {
+            throw new Error('Session not found');
+        }
+        console.log('✅ Session verified');
+
+        // Test conversation and message
+        const conversation = await prisma.conversation.findFirst({
+            include: { messages: true }
+        });
+        if (!conversation || !conversation.messages.length) {
+            throw new Error('Conversation or messages not found');
+        }
+        console.log('✅ Conversation and messages verified');
+
+        // Test suggestion
+        const suggestion = await prisma.suggestion.findFirst();
+        if (!suggestion) {
+            throw new Error('Suggestion not found');
+        }
+        console.log('✅ Suggestion verified');
+
+        console.log('✅ All smoke tests passed!');
+    } catch (error) {
+        console.error('❌ Smoke test failed:', error);
+        process.exit(1);
+    } finally {
+        await prisma.$disconnect();
+    }
+}
+
+smokeTest(); 

scripts/test-db-connection.ts

@@ -0,0 +1,21 @@
+import { PrismaClient } from '@prisma/client';
+
+async function testConnection() {
+    console.log('🔄 Testing database connection...');
+
+    try {
+        const prisma = new PrismaClient();
+        await prisma.$connect();
+
+        // Test query
+        const userCount = await prisma.user.count();
+        console.log(`✅ Database connection successful! Found ${userCount} users.`);
+
+        await prisma.$disconnect();
+    } catch (error) {
+        console.error('❌ Database connection failed:', error);
+        process.exit(1);
+    }
+}
+
+testConnection();