isSidebarOpen && setIsSidebarOpen(false)}
>
{/* Overlay for mobile or just general click-out behavior if desired, though the main content click handler handles it above */}
{isSidebarOpen && (
{/*
Pass isSidebarOpen to Chat if we want to selectively fade parts INSIDE Chat.
Or wrap Chat in a div that handles the fading of "maps and itinerary".
Since maps/itinerary are inside Chat, we can pass a prop or use CSS classes that cascade?
Actually, the user asked: "maps ans itinerary will fade out but chat will stay"
The Chat component handles the layout of Left Panel (Chat) and Right Panel (Map/Itinerary).
We can't easily fade *half* the component from outside without passing a prop.
Let's pass `isSidebarOpen` to Chat as a prop `isSidebarOpen`.
*/}
{sessionId &&
setIsSidebarOpen(false)} />
)}
);
}
```
### src/app/login/page.tsx
```typescript
import { auth } from "@/auth"
import { redirect } from "next/navigation"
import AnimatedDiamondGrid from "@/components/AnimatedDiamondGrid"
import GopherLogo from "@/components/GopherLogo"
import LoginNavbar from "@/components/LoginNavbar"
import { ArrowDown } from "lucide-react"
import { FeaturesGrid, TechnologiesGrid } from "@/components/AnimatedStats"
export const metadata = {
title: "Gopher - Login",
}
export default async function LoginPage() {
const session = await auth()
// If already logged in, redirect to main app
if (session?.user) {
redirect('/')
}
// Diamond grid parameters
const rows = 5;
const cols = 25;
const diamondSize = 70;
const gap = 10;
return (
{
// Check if we have a valid cached token
if (cachedToken && cachedToken.expiresAt > Date.now()) {
return cachedToken.token;
}
const apiKey = process.env.AMADEUS_API_KEY;
const apiSecret = process.env.AMADEUS_API_SECRET;
if (!apiKey || !apiSecret) {
throw new Error('Amadeus API credentials not configured');
}
const response = await fetch('https://test.api.amadeus.com/v1/security/oauth2/token', {
method: 'POST',
headers: {
'Content-Type': 'application/x-www-form-urlencoded',
},
body: new URLSearchParams({
grant_type: 'client_credentials',
client_id: apiKey,
client_secret: apiSecret,
}),
});
if (!response.ok) {
const error = await response.text();
console.error('Amadeus auth error:', error);
throw new Error('Failed to authenticate with Amadeus');
}
const data = await response.json();
// Cache the token (expires in ~30 minutes, we'll refresh at 25)
cachedToken = {
token: data.access_token,
expiresAt: Date.now() + (data.expires_in - 300) * 1000, // Refresh 5 min early
};
return data.access_token;
}
export async function GET(req: NextRequest) {
const searchParams = req.nextUrl.searchParams;
const lat = searchParams.get('lat');
const lng = searchParams.get('lng');
const checkIn = searchParams.get('checkIn') || getDefaultCheckIn();
const checkOut = searchParams.get('checkOut') || getDefaultCheckOut();
const radiusInMeters = parseInt(searchParams.get('radius') || '5000');
// Force larger radius in test environment to find hotels (min 20km)
const radius = Math.max(20, Math.ceil(radiusInMeters / 1000));
const adults = searchParams.get('adults') || '1';
if (!lat || !lng) {
return NextResponse.json({ error: 'Missing lat/lng parameters' }, { status: 400 });
}
try {
const token = await getAmadeusToken();
// First, get hotel list by location
const hotelsUrl = `https://test.api.amadeus.com/v1/reference-data/locations/hotels/by-geocode?latitude=${lat}&longitude=${lng}&radius=${radius}&radiusUnit=KM&hotelSource=ALL`;
console.log('Fetching hotels by location...');
const hotelsResponse = await fetch(hotelsUrl, {
headers: { Authorization: `Bearer ${token}` },
});
if (!hotelsResponse.ok) {
const error = await hotelsResponse.text();
console.error('Hotels list error:', error);
return NextResponse.json({ error: 'Failed to fetch hotels list' }, { status: 500 });
}
const hotelsData = await hotelsResponse.json();
const hotelIds = hotelsData.data?.slice(0, 10).map((h: any) => h.hotelId) || []; // eslint-disable-line @typescript-eslint/no-explicit-any
if (hotelIds.length === 0) {
return NextResponse.json({ hotels: [], message: 'No hotels found in this area' });
}
// Get hotel offers (prices) for these hotels
const offersUrl = `https://test.api.amadeus.com/v3/shopping/hotel-offers?hotelIds=${hotelIds.join(',')}&adults=${adults}&checkInDate=${checkIn}&checkOutDate=${checkOut}¤cy=USD`;
console.log('Fetching hotel offers...');
const offersResponse = await fetch(offersUrl, {
headers: { Authorization: `Bearer ${token}` },
});
if (!offersResponse.ok) {
const error = await offersResponse.text();
console.error('Hotel offers error:', error);
// Return hotels without prices if offers fail
return NextResponse.json({
hotels: hotelsData.data.slice(0, 10).map((h: any) => ({ // eslint-disable-line @typescript-eslint/no-explicit-any
id: h.hotelId,
name: h.name,
address: h.address?.countryCode || '',
location: { lat: h.geoCode?.latitude, lng: h.geoCode?.longitude },
price: null,
priceLabel: 'Price unavailable',
rating: null,
})),
});
}
const offersData = await offersResponse.json();
console.log('Hotel offers data sample:', JSON.stringify(offersData.data?.[0], null, 2));
// Transform to our format
const hotels = (offersData.data || []).map((hotel: any) => { // eslint-disable-line @typescript-eslint/no-explicit-any
const offer = hotel.offers?.[0];
const price = offer?.price?.total;
// Amadeus returns star rating (1-5), not user ratings
const starRating = hotel.hotel?.rating ? parseInt(hotel.hotel.rating) : null;
return {
id: hotel.hotel?.hotelId,
name: hotel.hotel?.name,
address: hotel.hotel?.address?.lines?.join(', ') || '',
city: hotel.hotel?.address?.cityName || '',
location: {
lat: hotel.hotel?.latitude,
lng: hotel.hotel?.longitude,
},
price: price ? parseFloat(price) : null,
priceLabel: price ? `$${parseFloat(price).toFixed(0)}/night` : 'Price N/A',
currency: offer?.price?.currency || 'USD',
rating: starRating, // This is star rating (1-5), not user review rating
starRating: starRating,
amenities: hotel.hotel?.amenities?.slice(0, 5) || [],
roomType: offer?.room?.description?.text || '',
checkIn,
checkOut,
};
});
return NextResponse.json({ hotels });
} catch (error: any)
[truncated — 574 more characters]
```
[18 more indexed source files omitted to keep this export small. The full file list is in the Codebase structure section above.]
{/* Navbar - Sticky */}
)
}
```
### src/app/api/distance/route.ts
```typescript
import { NextRequest, NextResponse } from 'next/server';
interface DistanceRequest {
origin: { lat: number; lng: number };
destinations: Array<{ lat: number; lng: number; id: string }>;
}
export async function POST(req: NextRequest) {
const apiKey = process.env.GOOGLE_API_KEY;
if (!apiKey) {
return NextResponse.json({ error: 'Google API key not configured' }, { status: 500 });
}
try {
const body: DistanceRequest = await req.json();
const { origin, destinations } = body;
if (!origin || !destinations || destinations.length === 0) {
return NextResponse.json({ error: 'Missing origin or destinations' }, { status: 400 });
}
// Format origins and destinations for the API
const originStr = `${origin.lat},${origin.lng}`;
const destinationsStr = destinations.map(d => `${d.lat},${d.lng}`).join('|');
const url = `https://maps.googleapis.com/maps/api/distancematrix/json?origins=${originStr}&destinations=${destinationsStr}&units=imperial&key=${apiKey}`;
const response = await fetch(url);
const data = await response.json();
if (data.status !== 'OK') {
console.error('Distance Matrix API error:', data);
return NextResponse.json({ error: `Distance API error: ${data.status}` }, { status: 500 });
}
// Transform results
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const distances = data.rows[0].elements.map((element: any, index: number) => ({
id: destinations[index].id,
distance: element.distance?.text || 'N/A',
distanceMeters: element.distance?.value || 0,
duration: element.duration?.text || 'N/A',
durationSeconds: element.duration?.value || 0,
status: element.status,
}));
return NextResponse.json({ distances });
} catch (error) {
console.error('Error calculating distances:', error);
return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
}
}
```
### src/app/api/events/route.ts
```typescript
import { NextRequest, NextResponse } from 'next/server';
export async function GET(req: NextRequest) {
const searchParams = req.nextUrl.searchParams;
const keyword = searchParams.get('keyword');
if (!keyword) {
return NextResponse.json({ error: 'Missing keyword parameter' }, { status: 400 });
}
const apiKey = process.env.TICKETMASTER_API_KEY;
if (!apiKey) {
return NextResponse.json({ error: 'Ticketmaster API key not configured' }, { status: 500 });
}
try {
const url = `https://app.ticketmaster.com/discovery/v2/events.json?keyword=${encodeURIComponent(keyword)}&apikey=${apiKey}&size=10`;
const response = await fetch(url);
const data = await response.json();
if (!response.ok) {
console.error('Ticketmaster API error:', data);
return NextResponse.json({ error: 'Failed to fetch events' }, { status: 500 });
}
// Extract relevant event information
// eslint-disable-next-line @typescript-eslint/no-explicit-any
const events = data._embedded?.events?.map((event: any) => {
const venue = event._embedded?.venues?.[0];
return {
id: event.id,
name: event.name,
date: event.dates?.start?.localDate || 'TBD',
time: event.dates?.start?.localTime || '',
venue: venue?.name || 'Venue TBD',
city: venue?.city?.name || '',
state: venue?.state?.stateCode || '',
// Add venue coordinates for Google Places search
location: venue?.location ? {
lat: parseFloat(venue.location.latitude),
lng: parseFloat(venue.location.longitude),
} : null,
// eslint-disable-next-line @typescript-eslint/no-explicit-any
image: event.images?.find((img: any) => img.ratio === '16_9' && img.width > 500)?.url
|| event.images?.[0]?.url
|| '',
url: event.url,
priceRange: event.priceRanges?.[0]
? `$${event.priceRanges[0].min} - $${event.priceRanges[0].max}`
: 'Price TBD',
};
}) || [];
return NextResponse.json({ events });
} catch (error) {
console.error('Error fetching events:', error);
return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
}
}
```
### src/app/api/chat/route.ts
```typescript
import { groq } from '@ai-sdk/groq';
import { streamText } from 'ai';
// Allow streaming responses up to 30 seconds
export const maxDuration = 30;
export async function POST(req: Request) {
try {
const { messages } = await req.json();
console.log('Chat request with', messages.length, 'messages');
const result = await streamText({
model: groq('meta-llama/llama-4-scout-17b-16e-instruct'),
system: `You are an event planner helping users find hotels and restaurants near events.
CRITICAL RULES:
1. For greetings (hi, hello), respond normally.
1. For greetings (hi, hello), respond normally.
2. When user mentions an artist/event they want to see, IMMEDIATELY response with "Searching for events..." and include EXACTLY this format:
[SEARCH_EVENT: name]
examples:
User: "Drake" -> [SEARCH_EVENT: Drake]
User: "Taylor Swift" -> [SEARCH_EVENT: Taylor Swift]
NEVER use other formats like [Drake_Event] or [DRAW_Event].
3. **EVENT SELECTION Handling**:
When user says "I want to attend: [Event Name]...", DO NOT ask what event they want. You already know.
IMMEDIATELY response: "Great choice! [ASK_HOTELS] Would you like to look for hotels or restaurants nearby?"
CRITICAL: You MUST include [ASK_HOTELS] in the response. This triggers the hotel search buttons.
4. **HOTEL SEARCH Trigger**:
When user asks for hotels or gives hotel preferences, include this trigger:
[FIND_PLACES: type=hotel | budget=cheap | rating=4 | radius=8000]
- budget: cheap, moderate, expensive
- rating: 0-5
- radius: 800 (walking), 1600 (nearby), 8000 (driving)
5. **RESTAURANT SEARCH Trigger**:
When user asks for restaurants, FIRST ask: "Should they be near the venue or near your hotel?" unless already specified.
Then ask for cuisine/budget.
When preferences given:
[FIND_PLACES: type=restaurant | budget=moderate | rating=4 | radius=1600]
IMPORTANT:
- NEVER ask "what event" after the user just selected one.
- You can search for restaurants OR hotels in any order.
- ALWAYS include [FIND_PLACES: ...] when preferences are given.`,
messages: messages.map((m: any) => ({ role: m.role, content: m.content })), // eslint-disable-line @typescript-eslint/no-explicit-any
});
return result.toTextStreamResponse();
} catch (error: any) { // eslint-disable-next-line @typescript-eslint/no-explicit-any
console.error('API ROUTE ERROR:', error);
return new Response(JSON.stringify({ error: 'Internal Server Error' }), { status: 500 });
}
}
```
### src/app/api/places/route.ts
```typescript
import { NextRequest, NextResponse } from 'next/server';
export async function GET(req: NextRequest) {
const searchParams = req.nextUrl.searchParams;
const lat = searchParams.get('lat');
const lng = searchParams.get('lng');
const type = searchParams.get('type') || 'restaurant'; // restaurant, lodging
const radius = searchParams.get('radius') || '1500'; // meters
const minRating = parseFloat(searchParams.get('minRating') || '0');
const maxPrice = parseInt(searchParams.get('maxPrice') || '4'); // 1-4 scale
const keyword = searchParams.get('keyword') || '';
if (!lat || !lng) {
return NextResponse.json({ error: 'Missing lat/lng parameters' }, { status: 400 });
}
const apiKey = process.env.GOOGLE_API_KEY;
if (!apiKey) {
return NextResponse.json({ error: 'Google API key not configured' }, { status: 500 });
}
try {
// Use Google Places Nearby Search
let url = `https://maps.googleapis.com/maps/api/place/nearbysearch/json?location=${lat},${lng}&radius=${radius}&type=${type}&key=${apiKey}`;
if (keyword) {
url += `&keyword=${encodeURIComponent(keyword)}`;
}
console.log('Places API request URL:', url.replace(apiKey, 'API_KEY_HIDDEN'));
const response = await fetch(url);
const data = await response.json();
console.log('Places API response status:', data.status);
console.log('Places API results count:', data.results?.length || 0);
if (data.status !== 'OK' && data.status !== 'ZERO_RESULTS') {
console.error('Google Places API error:', JSON.stringify(data, null, 2));
return NextResponse.json({
error: `Places API error: ${data.status}`,
message: data.error_message || 'Unknown error',
details: data
}, { status: 500 });
}
// Filter and transform results
// Filter and transform results
const places = (data.results || [])
// eslint-disable-next-line @typescript-eslint/no-explicit-any
.filter((place: any) => {
// Filter by rating
if (minRating > 0 && (!place.rating || place.rating < minRating)) {
return false;
}
// Filter by price level
if (place.price_level !== undefined && place.price_level > maxPrice) {
return false;
}
return true;
})
.slice(0, 10) // Limit to 10 results
// eslint-disable-next-line @typescript-eslint/no-explicit-any
.map((place: any) => ({
id: place.place_id,
name: place.name,
address: place.vicinity,
rating: place.rating || 0,
userRatingsTotal: place.user_ratings_total || 0,
priceLevel: place.price_level, // 0-4
priceLabel: getPriceLabel(place.price_level),
types: place.types,
location: {
lat: place.geometry.location.lat,
lng: place.geometry.location.lng,
},
photo: place.photos?.[0]?.photo_reference
? `https://maps.googleapis.com/maps/api/place/photo?maxwidth=400&photo_reference=${place.photos[0].photo_reference}&key=${apiKey}`
: null,
openNow: place.opening_hours?.open_now,
}));
return NextResponse.json({ places });
} catch (error) {
console.error('Error fetching places:', error);
return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
}
}
function getPriceLabel(priceLevel: number | undefined): string {
switch (priceLevel) {
case 0: return 'Free';
case 1: return '$';
case 2: return '$$';
case 3: return '$$$';
case 4: return '$$$$';
default: return 'Price N/A';
}
}
```
### src/app/api/hotels/route.ts
```typescript
import { NextRequest, NextResponse } from 'next/server';
// Cache token to avoid re-authenticating every request
let cachedToken: { token: string; expiresAt: number } | null = null;
async function getAmadeusToken(): Promise
{/* Left Side */}
Your AI travel companion