No apartments found
Try a different query or adjust your filters.
`;
addSystemMessage('No apartments found');
return;
}
apartmentsContainer.innerHTML = '';
apartments.forEach((apt, index) => {
const card = createApartmentCard(apt, index + 1);
apartmentsContainer.appendChild(card);
});
addSystemMessage(`✓ Displaying ${apartments.length} apartment(s)`);
}
// Create apartment card element
function createApartmentCard(apt, number) {
const card = document.createElement('div');
card.className = 'apartment-card';
// Load full metadata if available
const price = apt.price || 'N/A';
const address = apt.address || 'N/A';
const listingUrl = apt.listing_url || null;
// Check for additional data
[truncated — 14343 more characters]
```
### brightdata_api_demo.js
```javascript
/**
* Bright Data API Demo
* Direct HTTP requests - maximum control and flexibility
*/
import 'dotenv/config';
import fetch from 'node-fetch';
import fs from 'fs';
import path from 'path';
const CONFIG = {
apiKey: process.env.BRIGHTDATA_API_KEY,
serpZone: process.env.SERP_ZONE,
unlockerZone: process.env.UNLOCKER_ZONE,
endpoint: 'https://api.brightdata.com/request'
};
console.log('METHOD 1: Direct API Requests\n');
// Example 1: Search
async function demoSearch(maxResults = 10) {
console.log('Example 1: Searching Google...');
const searchUrl = 'https://www.google.com/search?q=web+scraping+2025&brd_json=1';
const response = await fetch(CONFIG.endpoint, {
method: 'POST',
headers: {
'Authorization': `Bearer ${CONFIG.apiKey}`,
'Content-Type': 'application/json'
},
body: JSON.stringify({
zone: CONFIG.serpZone,
url: searchUrl,
format: 'raw'
})
});
const data = await response.json();
const results = data.organic || [];
console.log(`Found ${results.length} results:`);
results.forEach((r, i) => console.log(` ${i + 1}. ${r.title}`));
console.log();
// Collect up to maxResults URLs
const urls = [];
for (const r of results) {
const u = r?.link || r?.url || r?.href;
if (u) urls.push(u);
if (urls.length >= maxResults) break;
}
return urls;
}
// Example 2: Fetch multiple pages concurrently and save as HTML
async function demoFetchAll(urls) {
console.log('Example 2: Fetching page content (concurrent)...');
if (!urls || urls.length === 0) {
console.log(' No URLs to fetch; skipping.');
return [];
}
const outDir = path.join(process.cwd(), 'out');
if (!fs.existsSync(outDir)) {
fs.mkdirSync(outDir, { recursive: true });
}
function sanitizeFilename(str) {
return str.replace(/[^a-z0-9._-]/gi, '-').slice(0, 120);
}
const jobs = urls.map((url, idx) => (async () => {
try {
const res = await fetch(CONFIG.endpoint, {
method: 'POST',
headers: {
'Authorization': `Bearer ${CONFIG.apiKey}`,
'Content-Type': 'application/json'
},
body: JSON.stringify({
zone: CONFIG.unlockerZone,
url,
format: 'raw',
data_format: 'html'
})
});
const html = await res.text();
const u = new URL(url);
const baseName = `${String(idx + 1).padStart(2, '0')}-${sanitizeFilename(u.hostname + u.pathname) || 'page'}.html`;
const filePath = path.join(outDir, baseName);
fs.writeFileSync(filePath, html, 'utf8');
console.log(` Saved: ${filePath} (${html.length} chars)`);
return { url, filePath, length: html.length };
} catch (err) {
console.log(` Failed: ${url} (${err.message})`);
return { url, error: err.message };
}
})());
const results = await Promise.all(jobs);
console.log();
return results;
}
// Run demos
async function main() {
try {
const urls = await demoSearch(10);
await demoFetchAll(urls);
console.log('API demos complete');
console.log('\nKey Points:');
console.log(' - Simple HTTP POST requests');
console.log(' - Works with any HTTP client');
console.log(' - Bright Data handles blocking/CAPTCHAs');
} catch (error) {
console.error('Error:', error.message);
process.exit(1);
}
}
main();
```
### cache-manager.js
```javascript
/**
* Cache Manager Module
* Handles data storage, caching, and file management
*/
import fs from 'fs';
import path from 'path';
import crypto from 'crypto';
import { CONFIG } from './api-services.js';
import { normalizeQuery, areQueriesSimilar } from './api-services.js';
// Create output directory if it doesn't exist
if (!fs.existsSync(CONFIG.outputDir)) {
fs.mkdirSync(CONFIG.outputDir, { recursive: true });
}
// ============================================================================
// UNIQUE ID GENERATION
// ============================================================================
/**
* Generate a unique, deterministic ID for an apartment based on its URL
* This allows consistent identification across different data sources
*/
export function generateApartmentId(url) {
const hash = crypto.createHash('sha256').update(url).digest('hex');
return `apt_${hash.substring(0, 12)}`;
}
// ============================================================================
// URL CACHE MANAGEMENT
// ============================================================================
/**
* Load cache of previously scraped URLs from metadata files
*/
export function loadScrapedURLsCache() {
const cache = new Map();
if (!fs.existsSync(CONFIG.outputDir)) {
return cache;
}
const files = fs.readdirSync(CONFIG.outputDir);
const metadataFiles = files.filter(f => f.endsWith('.json') && !f.includes('index') && !f.includes('cache') && !f.includes('distance'));
metadataFiles.forEach(file => {
try {
const metadata = JSON.parse(fs.readFileSync(path.join(CONFIG.outputDir, file), 'utf8'));
if (metadata.listing_url) {
cache.set(metadata.listing_url, {
apartmentId: metadata.apartment_id || file.replace('.json', ''),
htmlFile: file.replace('.json', '.html'),
metadataFile: file,
scrapedAt: metadata.scraped_at
});
}
} catch (error) {
// Skip invalid files
}
});
return cache;
}
/**
* Check if a URL has already been scraped
*/
export function isAlreadyScraped(url, cache) {
return cache.has(url);
}
// ============================================================================
// FILE STORAGE
// ============================================================================
/**
* Save raw HTML and metadata for an apartment
*/
export function saveRawHTML(html, listing, index) {
const apartmentId = generateApartmentId(listing.listing_url);
const htmlFilename = `${apartmentId}.html`;
const metadataFilename = `${apartmentId}.json`;
const htmlPath = path.join(CONFIG.outputDir, htmlFilename);
const metadataPath = path.join(CONFIG.outputDir, metadataFilename);
// Save raw HTML
fs.writeFileSync(htmlPath, html, 'utf8');
// Save metadata
const metadata = {
apartment_id: apartmentId,
address: listing.address || 'N/A',
price: listing.price || 'N/A',
listing_url: listing.listing_url || 'N/A',
scraped_at: new Date().toISOString(),
html_file: htmlFilename,
html_size_bytes: html.length
};
fs.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2));
console.log(`[Storage] ✅ Saved HTML: ${htmlFilename}`);
console.log(`[Storage] ✅ Saved metadata: ${metadataFilename}`);
console.log(`[Storage] 🆔 Apartment ID: ${apartmentId}`);
return { htmlPath, metadataPath, apartmentId };
}
/**
* Load HTML content for an apartment
*/
export function loadApartmentHTML(apartmentId) {
const htmlPath = path.join(CONFIG.outputDir, `${apartmentId}.html`);
if (fs.existsSync(htmlPath)) {
try {
return fs.readFileSync(htmlPath, 'utf8');
} catch (error) {
return null;
}
}
return null;
}
/**
* Updates the master index file with all apartments
*/
export function updateMasterIndex(apartments) {
const indexPath = path.join(CONFIG.outputDir, 'apartments_index.json');
let existingIndex = [];
if (fs.existsSync(indexPath)) {
try {
existingIndex = JSON.parse(fs.readFileSync(indexPath, 'utf8'));
} catch (error) {
console.log('[Index] Creating new index file');
}
}
const indexMap = new Map(existingIndex.map(apt => [apt.apartment_id, apt]));
apartments.forEach(apt => {
indexMap.set(apt.apartment_id, {
apartment_id: apt.apartment_id,
address: apt.address,
price: apt.price,
listing_url: apt.listing_url,
last_updated: new Date().toISOString()
});
});
const updatedIndex = Array.from(indexMap.values())
.sort((a, b) => new Date(b.last_updated) - new Date(a.last_updated));
fs.writeFileSync(indexPath, JSON.stringify(updatedIndex, null, 2));
console.log(`\n[Index] ✅ Updated master index: ${updatedIndex.length} total apartments`);
console.log(`[Index] 📄 File: apartments_index.json`);
}
// ============================================================================
// INTELLIGENT QUERY CACHING
// ============================================================================
/**
* Load query cache from disk
*/
export function loadQueryCache() {
const cachePath = path.join(CONFIG.outputDir, 'query_cache.json');
if (fs.existsSync(cachePath)) {
try {
const cache = JSON.parse(fs.readFileSync(cachePath, 'utf8'));
return cache.queries || [];
} catch (error) {
console.log('[Query Cache] Creating new cache file');
return [];
}
}
return [];
}
/**
* Save query to cache
*/
export function saveQueryToCache(queryData) {
const cachePath = path.join(CONFIG.outputDir, 'query_cache.json');
const cache = loadQueryCache();
cache.push(queryData);
fs.writeFileSync(cachePath, JSON.stringify({ queries: cache }, null, 2));
console.log(`[Query Cache] Saved query cache`);
}
/**
* Check if we have cached results for a similar query
*/
export async function checkQueryCache(userQuery) {
console.log('\n[Query Cache] Checking for similar previous searches...');
const cache = loadQueryC
[truncated — 8885 more characters]
```
### apartment-finder-new.js
```javascript
/**
* Apartment Finder - Main Orchestration & CLI
* Coordinates the apartment search process and provides user interface
*/
import readline from 'readline';
import fs from 'fs';
import path from 'path';
import fetch from 'node-fetch';
// Import API services
import {
CONFIG,
searchGoogle,
scrapeUrl,
quickExtractListings,
normalizeQuery,
interpretLocationWithAI,
geocodeAddress,
calculateDistance
} from './api-services.js';
// Import cache management
import {
generateApartmentId,
loadScrapedURLsCache,
isAlreadyScraped,
saveRawHTML,
updateMasterIndex,
checkQueryCache,
loadApartmentsByIds,
saveQueryToCache,
saveDistanceData
} from './cache-manager.js';
// ============================================================================
// FILTERING FUNCTIONS
// ============================================================================
function filterApartmentSites(serpResults) {
const excludeDomains = [
'zillow.com',
'youtube.com',
'facebook.com',
'twitter.com',
'linkedin.com',
'wikipedia.org',
'pinterest.com'
];
return serpResults.filter(result => {
const link = result.link || '';
const title = (result.title || '').toLowerCase();
const isExcluded = excludeDomains.some(domain => link.includes(domain));
if (isExcluded) return false;
const apartmentKeywords = ['apartment', 'rental', 'housing', 'rent', 'property', 'lease'];
const hasKeyword = apartmentKeywords.some(keyword => title.includes(keyword) || link.includes(keyword));
return hasKeyword;
});
}
// ============================================================================
// PRICE EXTRACTION AND FILTERING
// ============================================================================
function extractMaxPrice(query) {
const patterns = [
/under\s+\$?([\d,]+)/i,
/below\s+\$?([\d,]+)/i,
/less than\s+\$?([\d,]+)/i,
/max\s+\$?([\d,]+)/i,
/maximum\s+\$?([\d,]+)/i,
/\$?([\d,]+)\s+or less/i,
];
for (const pattern of patterns) {
const match = query.match(pattern);
if (match) {
return parseInt(match[1].replace(/,/g, ''));
}
}
return null;
}
function filterByPrice(listings, maxPrice) {
if (!maxPrice) return listings;
return listings.filter(listing => {
if (!listing.price || listing.price === 'N/A') return true;
const priceMatch = listing.price.match(/\$?([\d,]+)/);
if (priceMatch) {
const price = parseInt(priceMatch[1].replace(/,/g, ''));
return price <= maxPrice;
}
return true;
});
}
// ============================================================================
// DISTANCE QUERY PARSING
// ============================================================================
function parseDistanceQuery(query) {
const patterns = [
/within\s+(\d+(?:\.\d+)?)\s+(mile|miles|mi|meter|meters|m|km|kilometer|kilometers)\s+(?:of|from)\s+(.+)/i,
/less\s+than\s+(\d+(?:\.\d+)?)\s+(mile|miles|mi|meter|meters|m|km|kilometer|kilometers)\s+(?:of|from)\s+(.+)/i,
/under\s+(\d+(?:\.\d+)?)\s+(mile|miles|mi|meter|meters|m|km|kilometer|kilometers)\s+(?:of|from)\s+(.+)/i,
];
for (const pattern of patterns) {
const match = query.match(pattern);
if (match) {
const distance = parseFloat(match[1]);
const unit = match[2].toLowerCase();
const location = match[3].trim();
let distanceInMiles = distance;
if (unit.startsWith('m') && !unit.startsWith('mi')) {
distanceInMiles = distance * 0.000621371;
} else if (unit.startsWith('km')) {
distanceInMiles = distance * 0.621371;
}
return { distance: distanceInMiles, unit, originalDistance: distance, location };
}
}
return null;
}
// ============================================================================
// MAIN APARTMENT FINDER LOGIC
// ============================================================================
async function findApartments(userQuery) {
console.log('\n' + '='.repeat(80));
console.log('APARTMENT FINDER - INTELLIGENT QUERY CACHING');
console.log('='.repeat(80));
console.log(`Query: ${userQuery}\n`);
// Check query cache first!
const cachedQueryResult = await checkQueryCache(userQuery);
if (cachedQueryResult && cachedQueryResult.apartment_ids.length > 0) {
console.log(`\n${'='.repeat(80)}`);
console.log('USING CACHED RESULTS - SKIPPING STAGE 1 & 2');
console.log('='.repeat(80));
console.log(`[Cache] Loading ${cachedQueryResult.apartment_ids.length} apartments from previous search...`);
const apartments = loadApartmentsByIds(cachedQueryResult.apartment_ids);
console.log(`[Cache] ✅ Loaded ${apartments.length} apartments from cache`);
console.log(`[Cache] 💰 Saved API costs by reusing existing data!`);
return apartments;
}
console.log('\n[New Search] Proceeding with Stage 1 & 2...');
const maxPrice = extractMaxPrice(userQuery);
if (maxPrice) {
console.log(`[Filter] Max price detected: $${maxPrice}`);
}
// ===== STAGE 1: Find Listing Pages =====
console.log('\n' + '='.repeat(60));
console.log('STAGE 1: SCANNING FOR LISTINGS');
console.log('='.repeat(60));
const enhancedQuery = `${userQuery} apartments rent`;
const serpResults = await searchGoogle(enhancedQuery, 10);
if (serpResults.length === 0) {
console.log('\n❌ No search results found');
return [];
}
const filteredResults = filterApartmentSites(serpResults);
const topResults = filteredResults.slice(0, 5);
console.log(`\n[Stage 1] Found ${topResults.length} relevant sites (excluding Zillow):`);
topResults.forEach((result, i) => {
console.log(` ${i + 1}. ${result.title?.substring(0, 60) || 'N/A'}...`);
console.log(` ${result.link || 'N/A'}`);
});
if (topResults.length === 0) {
console.log('\n❌ No relevant sites found');
return [];
}
const allBasicListings = [];
for (const result of topResults) {
c
[truncated — 13898 more characters]
```
### web-server.js
```javascript
/**
* Web Server for Apartment Finder
* Provides web interface while maintaining CLI backend flow
*/
import express from 'express';
import path from 'path';
import { fileURLToPath } from 'url';
import fs from 'fs';
import fetch from 'node-fetch';
// Import backend functions
import {
CONFIG,
searchGoogle,
scrapeUrl,
quickExtractListings,
extractApartmentDetails,
extractManagementName,
analyzeManagement,
detectResearchAgent,
runSecurityResearch,
runAccessibilityResearch,
runPetFriendlinessResearch,
runLifestyleResearch,
interpretLocationWithAI,
geocodeAddress,
calculateDistance
} from './api-services.js';
import {
generateApartmentId,
loadScrapedURLsCache,
isAlreadyScraped,
saveRawHTML,
checkQueryCache,
loadApartmentsByIds,
saveQueryToCache,
saveManagementAnalysis,
loadManagementAnalysis,
loadApartmentHTML,
saveAgentResearch,
loadAgentResearch,
saveDistanceData,
loadDistanceData,
generateLocationKey,
saveApartmentCoordinates,
loadApartmentCoordinates
} from './cache-manager.js';
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);
const app = express();
const PORT = 3000;
// Middleware
app.use(express.json());
app.use(express.static('public'));
// Store active SSE connections
const clients = new Map();
// Helper function to send messages to frontend
function sendToClient(clientId, type, data) {
const client = clients.get(clientId);
if (client) {
try {
client.write(`data: ${JSON.stringify({ type, data })}\n\n`);
} catch (error) {
console.error('Error sending to client:', error.message);
clients.delete(clientId);
}
}
}
// Helper functions for query detection
function parseLookIntoQuery(query) {
const patterns = [
/look (?:into|at|closely at) (?:apartment |apt )?(\d+)/i,
/show (?:me )?(?:apartment |apt )?(\d+)/i,
/details? (?:for|of|on) (?:apartment |apt )?(\d+)/i,
/apartment (\d+) details?/i
];
for (const pattern of patterns) {
const match = query.match(pattern);
if (match) return parseInt(match[1]);
}
return null;
}
function parseKeepTopKQuery(query) {
const patterns = [
/keep (?:top |first )?(\d+)/i,
/show (?:only |me |top |first )?(\d+)/i,
/limit (?:to )?(\d+)/i,
/first (\d+)/i,
/top (\d+)/i
];
for (const pattern of patterns) {
const match = query.match(pattern);
if (match) return parseInt(match[1]);
}
return null;
}
function isManagementAnalysisQuery(query) {
const keywords = ['detail', 'report', 'summary', 'information', 'analysis', 'management', 'review', 'quality', 'score'];
return keywords.some(keyword => query.toLowerCase().includes(keyword));
}
function filterApartmentSites(serpResults) {
const excludeDomains = ['zillow.com', 'youtube.com', 'facebook.com', 'twitter.com'];
return serpResults.filter(result => {
const link = result.link || '';
const isExcluded = excludeDomains.some(domain => link.includes(domain));
if (isExcluded) return false;
const apartmentKeywords = ['apartment', 'rental', 'housing', 'rent', 'property'];
const title = (result.title || '').toLowerCase();
return apartmentKeywords.some(keyword => link.includes(keyword) || title.includes(keyword));
});
}
// Main apartment search function
async function findApartments(userQuery, clientId) {
sendToClient(clientId, 'log', 'APARTMENT FINDER - INTELLIGENT QUERY CACHING');
// Check cache
const cachedQueryResult = await checkQueryCache(userQuery);
if (cachedQueryResult && cachedQueryResult.apartment_ids.length > 0) {
sendToClient(clientId, 'log', 'USING CACHED RESULTS - SKIPPING STAGE 1 & 2');
const apartments = loadApartmentsByIds(cachedQueryResult.apartment_ids);
// IMPORTANT: REPLACE the index (not merge) so subsequent filters work on THESE apartments only
const indexPath = path.join(CONFIG.outputDir, 'apartments_index.json');
fs.writeFileSync(indexPath, JSON.stringify(apartments, null, 2));
sendToClient(clientId, 'log', `✓ Working with ${apartments.length} apartments`);
const enriched = enrichApartmentsWithMetadata(apartments);
sendToClient(clientId, 'apartments', enriched);
return apartments;
}
sendToClient(clientId, 'log', 'New Search - Proceeding with Stage 1 & 2...');
// Stage 1: Search
sendToClient(clientId, 'log', 'STAGE 1: SCANNING FOR LISTINGS');
const enhancedQuery = `${userQuery} apartments rent`;
const serpResults = await searchGoogle(enhancedQuery, 10);
if (serpResults.length === 0) {
sendToClient(clientId, 'error', 'No search results found');
return [];
}
const filteredResults = filterApartmentSites(serpResults);
const topResults = filteredResults.slice(0, 5);
sendToClient(clientId, 'log', `Found ${topResults.length} relevant sites`);
const allBasicListings = [];
for (const result of topResults) {
const url = result.link;
if (!url) continue;
sendToClient(clientId, 'log', `Scraping: ${url.substring(0, 70)}...`);
const html = await scrapeUrl(url);
if (html) {
const listings = await quickExtractListings(html, url);
allBasicListings.push(...listings);
sendToClient(clientId, 'log', `✅ Found ${listings.length} listings`);
}
await new Promise(resolve => setTimeout(resolve, 2000));
}
sendToClient(clientId, 'log', `Total listings found: ${allBasicListings.length}`);
if (allBasicListings.length === 0) {
sendToClient(clientId, 'error', 'No apartments found');
return [];
}
// Stage 2: Deep scrape
sendToClient(clientId, 'log', 'STAGE 2: DEEP SCRAPE - PARALLEL MODE');
const urlCache = loadScrapedURLsCache();
const cachedApartments = [];
const apartmentsToScrape = [];
allBasicListings.forEach((listing) => {
if (!listing.listing_url || !listing.listing_url.startsWith('http')) return;
if (isAlreadyScraped(listing.listing_url, urlCache)) {
[truncated — 22104 more characters]
```
### public/styles.css
```css
/* Modern Monochrome Design for ADREI */
* {
margin: 0;
padding: 0;
box-sizing: border-box;
}
:root {
--primary-color: #000000;
--primary-dark: #1a1a1a;
--secondary-color: #333333;
--accent-color: #666666;
--success-color: #2d2d2d;
--success-dark: #1a1a1a;
--bg-primary: #ffffff;
--bg-secondary: #f8f8f8;
--bg-tertiary: #f0f0f0;
--text-primary: #000000;
--text-secondary: #666666;
--text-tertiary: #999999;
--border-color: #e0e0e0;
--border-hover: #cccccc;
--shadow-sm: 0 1px 2px 0 rgb(0 0 0 / 0.05);
--shadow-md: 0 4px 6px -1px rgb(0 0 0 / 0.1);
--shadow-lg: 0 10px 15px -3px rgb(0 0 0 / 0.1);
--radius-sm: 4px;
--radius-md: 8px;
--radius-lg: 12px;
}
body {
font-family: -apple-system, BlinkMacSystemFont, 'Inter', 'Segoe UI', Roboto, sans-serif;
background: var(--bg-secondary);
color: var(--text-primary);
line-height: 1.6;
-webkit-font-smoothing: antialiased;
}
.container {
display: flex;
height: 100vh;
overflow: hidden;
}
/* Main Content Area */
.main-content {
flex: 1;
display: flex;
flex-direction: column;
overflow: hidden;
background: var(--bg-secondary);
}
/* Header with Logo */
.header {
background: var(--bg-primary);
border-bottom: 2px solid var(--primary-color);
padding: 1.5rem 2rem;
}
.logo {
display: flex;
align-items: center;
gap: 1rem;
}
.logo-icon {
width: 48px;
height: 48px;
background: var(--primary-color);
border-radius: var(--radius-md);
display: flex;
align-items: center;
justify-content: center;
color: white;
font-size: 1.5rem;
}
.logo-text h1 {
font-family: 'Cormorant', serif;
font-size: 2.75rem;
font-weight: 700;
font-style: italic;
letter-spacing: 0.03em;
color: var(--text-primary);
}
.tagline {
font-size: 0.875rem;
color: var(--text-secondary);
font-weight: 500;
margin-top: 0.125rem;
}
/* Apartments Grid Container */
.apartments-grid {
flex: 1;
padding: 2rem;
overflow-y: auto;
display: grid;
grid-template-columns: repeat(auto-fill, minmax(380px, 1fr));
grid-auto-rows: max-content;
gap: 2rem;
align-content: start;
}
/* Welcome Message */
.welcome-message {
grid-column: 1 / -1;
background: var(--bg-primary);
border: 2px solid var(--primary-color);
border-radius: var(--radius-lg);
padding: 3rem;
text-align: center;
max-width: 700px;
margin: 2rem auto;
}
.welcome-icon {
width: 64px;
height: 64px;
background: var(--primary-color);
border-radius: 50%;
display: flex;
align-items: center;
justify-content: center;
color: white;
font-size: 2rem;
margin: 0 auto 1.5rem;
}
.welcome-message h2 {
font-size: 1.75rem;
font-weight: 700;
color: var(--text-primary);
margin-bottom: 0.75rem;
}
.welcome-desc {
color: var(--text-secondary);
font-size: 1rem;
line-height: 1.6;
margin-bottom: 2rem;
}
.example-queries {
margin-top: 2rem;
text-align: left;
}
.example-queries h3 {
font-size: 0.875rem;
font-weight: 600;
text-transform: uppercase;
letter-spacing: 0.05em;
color: var(--text-tertiary);
margin-bottom: 1rem;
}
.example-queries ul {
list-style: none;
display: flex;
flex-direction: column;
gap: 0.75rem;
}
.example-queries li {
padding: 0.875rem 1rem;
background: var(--bg-primary);
border: 1px solid var(--border-color);
border-radius: var(--radius-md);
color: var(--text-secondary);
font-size: 0.875rem;
transition: all 0.2s ease;
cursor: pointer;
display: flex;
align-items: center;
gap: 0.75rem;
}
.example-queries li i {
color: var(--primary-color);
width: 16px;
text-align: center;
}
.example-queries li:hover {
background: var(--bg-tertiary);
border-color: var(--primary-color);
color: var(--text-primary);
transform: translateX(4px);
}
/* ===== APARTMENT CARDS - SIMPLE & ROBUST ===== */
/* Card Container - Simple Flexbox */
.apartment-card {
background: var(--bg-primary);
border: 2px solid var(--border-color);
border-radius: var(--radius-lg);
box-shadow: var(--shadow-sm);
transition: all 0.3s ease;
display: block;
width: 100%;
min-height: 500px;
}
.apartment-card:hover {
border-color: var(--primary-color);
box-shadow: var(--shadow-lg);
transform: translateY(-2px);
}
/* Card Header */
.card-header {
background: var(--primary-color);
color: white;
padding: 2rem;
border-radius: var(--radius-lg) var(--radius-lg) 0 0;
}
.card-number {
font-size: 0.75rem;
font-weight: 700;
text-transform: uppercase;
letter-spacing: 0.05em;
opacity: 0.85;
margin: 0 0 0.75rem 0;
display: block;
}
.card-price {
font-size: 1.875rem;
font-weight: 700;
margin: 0 0 0.75rem 0;
display: block;
line-height: 1.2;
}
.card-address {
font-size: 0.9375rem;
opacity: 0.95;
line-height: 1.5;
margin: 0;
display: block;
}
/* Card Body */
.card-body {
padding: 2rem;
background: var(--bg-primary);
}
/* Distance Badge */
.card-distance {
background: var(--primary-color);
color: white;
padding: 1rem 1.25rem;
border-radius: var(--radius-md);
margin: 0 0 1.5rem 0;
display: inline-flex;
align-items: center;
gap: 0.625rem;
font-size: 0.875rem;
font-weight: 600;
}
.distance-icon {
font-size: 0.875rem;
}
/* Info Section */
.card-info {
margin: 0 0 1.5rem 0;
}
.info-row {
display: flex;
justify-content: space-between;
align-items: center;
padding: 1rem 0;
border-bottom: 1px solid var(--border-color);
}
.info-row:first-child {
padding-top: 0;
}
.info-row:last-child {
border-bottom: none;
padding-bottom: 0;
}
.info-label {
color: var(--text-secondary);
font-size: 0.875rem;
font-weight: 500;
display:
[truncated — 7782 more characters]
```
[1 more indexed source files omitted to keep this export small. The full file list is in the Codebase structure section above.]