removed old js backend

Signed-off-by: Vimal Kumar <[email protected]>

.gitignore

@@ -3,12 +3,12 @@ node_modules/
 */node_modules/
 
 # Environment variables
-.env
-.env.local
-.env.development.local
-.env.test.local
-.env.production.local
-.env.backup
+#.env
+# .env.local
+# .env.development.local
+# .env.test.local
+# .env.production.local
+# .env.backup
 
 # Additional security - API keys and secrets
 *.key

Dockerfile

@@ -30,7 +30,6 @@ RUN pip install --no-cache-dir --upgrade pip && \
 
 # Copy all source code
 COPY crossword-app/frontend/ ./frontend/
-COPY crossword-app/backend/ ./backend/
 COPY crossword-app/backend-py/ ./backend-py/
 
 # Copy cache directory with pre-built models and NLTK data
@@ -44,9 +43,6 @@ RUN cd frontend && npm run build
 # Copy built frontend files to Python backend public directory
 RUN mkdir -p backend-py/public && cp -r frontend/dist/* backend-py/public/
 
-# Create symlink for shared data (word lists)
-RUN cd backend-py && ln -sf ../backend/data data
-
 # Stage 2: Runtime - Copy only necessary files as non-root user
 FROM python:3.11-slim AS runtime
 
@@ -67,7 +63,6 @@ WORKDIR /app/backend-py
 
 # Copy built application files with correct ownership
 COPY --from=builder --chown=appuser:appuser /app/backend-py ./
-COPY --from=builder --chown=appuser:appuser /app/backend/data ./data
 
 # Copy cache directory to backend-py/cache for model and NLTK data
 COPY --from=builder --chown=appuser:appuser /app/cache-dir /app/backend-py/cache

crossword-app/backend/.env.example

@@ -1,68 +0,0 @@
-# Crossword App - Environment Configuration Template
-# Copy this file to .env and update with your actual values
-
-# Environment Configuration
-NODE_ENV=development
-PORT=3001
-
-# Database Configuration (Optional - using JSON files currently)
-DATABASE_URL=postgresql://username:password@localhost:5432/crossword_db
-DB_HOST=localhost
-DB_PORT=5432
-DB_NAME=crossword_db
-DB_USER=username
-DB_PASSWORD=password
-
-# CORS Configuration
-CORS_ORIGIN=http://localhost:5173,http://localhost:3000
-
-# Rate Limiting
-RATE_LIMIT_WINDOW_MS=900000
-RATE_LIMIT_MAX_REQUESTS=100
-GENERATE_RATE_LIMIT_MAX=10
-
-# Security
-JWT_SECRET=your-jwt-secret-key-change-in-production
-
-# Logging
-LOG_LEVEL=info
-
-# Cache Configuration (Optional - for Redis)
-REDIS_URL=redis://localhost:6379
-CACHE_TTL=3600
-
-# External APIs (Optional)
-DICTIONARY_API_KEY=your-dictionary-api-key
-WIKIPEDIA_API_ENDPOINT=https://en.wikipedia.org/api/rest_v1
-
-# =========================================
-# 🤖 AI/HUGGINGFACE CONFIGURATION
-# =========================================
-
-# HuggingFace API Configuration
-# Get your free API key at: https://huggingface.co/settings/tokens
-HUGGINGFACE_API_KEY=hf_xxxxxxxxxx
-
-# HuggingFace Model Configuration
-HUGGINGFACE_MODEL_ENDPOINT=https://api-inference.huggingface.co/models/sentence-transformers/all-MiniLM-L6-v2
-EMBEDDING_MODEL=sentence-transformers/all-MiniLM-L6-v2
-
-# LLM Configuration for Clue Generation  
-TEXT_GENERATION_MODEL=gpt2
-MAX_WORDS_PER_GENERATION=15
-CACHE_EMBEDDINGS=true
-
-# AI Word Generation Settings
-WORD_SIMILARITY_THRESHOLD=0.7
-MAX_TOPIC_WORDS=50
-FALLBACK_TO_STATIC=true
-USE_AI_WORDS=false
-
-# =========================================
-# 🚀 QUICK START INSTRUCTIONS
-# =========================================
-# 1. Copy this file: cp .env.example .env
-# 2. Get HuggingFace API key: https://huggingface.co/settings/tokens
-# 3. Replace HUGGINGFACE_API_KEY with your real key
-# 4. Optionally set USE_AI_WORDS=true to enable AI by default
-# 5. Start server: npm run dev

crossword-app/backend/data/word-lists/animals.json

@@ -1,165 +0,0 @@
-[
-  { "word": "DOG", "clue": "Man's best friend" },
-  { "word": "CAT", "clue": "Feline pet that purrs" },
-  { "word": "ELEPHANT", "clue": "Large mammal with a trunk" },
-  { "word": "TIGER", "clue": "Striped big cat" },
-  { "word": "WHALE", "clue": "Largest marine mammal" },
-  { "word": "BUTTERFLY", "clue": "Colorful flying insect" },
-  { "word": "BIRD", "clue": "Flying creature with feathers" },
-  { "word": "FISH", "clue": "Aquatic animal with gills" },
-  { "word": "LION", "clue": "King of the jungle" },
-  { "word": "BEAR", "clue": "Large mammal that hibernates" },
-  { "word": "RABBIT", "clue": "Hopping mammal with long ears" },
-  { "word": "HORSE", "clue": "Riding animal with hooves" },
-  { "word": "SHEEP", "clue": "Woolly farm animal" },
-  { "word": "GOAT", "clue": "Horned farm animal" },
-  { "word": "DUCK", "clue": "Water bird that quacks" },
-  { "word": "CHICKEN", "clue": "Farm bird that lays eggs" },
-  { "word": "SNAKE", "clue": "Slithering reptile" },
-  { "word": "TURTLE", "clue": "Shelled reptile" },
-  { "word": "FROG", "clue": "Amphibian that croaks" },
-  { "word": "SHARK", "clue": "Predatory ocean fish" },
-  { "word": "DOLPHIN", "clue": "Intelligent marine mammal" },
-  { "word": "PENGUIN", "clue": "Flightless Antarctic bird" },
-  { "word": "MONKEY", "clue": "Primate that swings in trees" },
-  { "word": "ZEBRA", "clue": "Striped African animal" },
-  { "word": "GIRAFFE", "clue": "Tallest land animal" },
-  { "word": "WOLF", "clue": "Wild canine that howls" },
-  { "word": "FOX", "clue": "Cunning red-furred animal" },
-  { "word": "DEER", "clue": "Graceful forest animal with antlers" },
-  { "word": "MOOSE", "clue": "Large antlered animal" },
-  { "word": "SQUIRREL", "clue": "Tree-climbing nut gatherer" },
-  { "word": "RACCOON", "clue": "Masked nocturnal animal" },
-  { "word": "BEAVER", "clue": "Dam-building rodent" },
-  { "word": "OTTER", "clue": "Playful water mammal" },
-  { "word": "SEAL", "clue": "Marine mammal with flippers" },
-  { "word": "WALRUS", "clue": "Tusked Arctic marine mammal" },
-  { "word": "RHINO", "clue": "Horned thick-skinned mammal" },
-  { "word": "HIPPO", "clue": "Large African river mammal" },
-  { "word": "CHEETAH", "clue": "Fastest land animal" },
-  { "word": "LEOPARD", "clue": "Spotted big cat" },
-  { "word": "JAGUAR", "clue": "South American big cat" },
-  { "word": "PUMA", "clue": "Mountain lion" },
-  { "word": "LYNX", "clue": "Wild cat with tufted ears" },
-  { "word": "KANGAROO", "clue": "Hopping Australian marsupial" },
-  { "word": "KOALA", "clue": "Eucalyptus-eating marsupial" },
-  { "word": "PANDA", "clue": "Black and white bamboo eater" },
-  { "word": "SLOTH", "clue": "Slow-moving tree dweller" },
-  { "word": "ARMADILLO", "clue": "Armored mammal" },
-  { "word": "ANTEATER", "clue": "Long-snouted insect eater" },
-  { "word": "PLATYPUS", "clue": "Egg-laying mammal with a bill" },
-  { "word": "BAT", "clue": "Flying mammal" },
-  { "word": "MOLE", "clue": "Underground tunnel digger" },
-  { "word": "HEDGEHOG", "clue": "Spiny small mammal" },
-  { "word": "PORCUPINE", "clue": "Quill-covered rodent" },
-  { "word": "SKUNK", "clue": "Black and white scent-spraying mammal" },
-  { "word": "WEASEL", "clue": "Small carnivorous mammal" },
-  { "word": "BADGER", "clue": "Burrowing black and white mammal" },
-  { "word": "FERRET", "clue": "Domesticated hunting animal" },
-  { "word": "MINK", "clue": "Valuable fur-bearing animal" },
-  { "word": "EAGLE", "clue": "Majestic bird of prey" },
-  { "word": "HAWK", "clue": "Sharp-eyed hunting bird" },
-  { "word": "OWL", "clue": "Nocturnal bird with large eyes" },
-  { "word": "FALCON", "clue": "Fast diving bird of prey" },
-  { "word": "VULTURE", "clue": "Scavenging bird" },
-  { "word": "CROW", "clue": "Black intelligent bird" },
-  { "word": "RAVEN", "clue": "Large black corvid" },
-  { "word": "ROBIN", "clue": "Red-breasted songbird" },
-  { "word": "SPARROW", "clue": "Small brown songbird" },
-  { "word": "CARDINAL", "clue": "Bright red songbird" },
-  { "word": "BLUEJAY", "clue": "Blue crested bird" },
-  { "word": "WOODPECKER", "clue": "Tree-pecking bird" },
-  { "word": "HUMMINGBIRD", "clue": "Tiny fast-flying bird" },
-  { "word": "PELICAN", "clue": "Large-billed water bird" },
-  { "word": "FLAMINGO", "clue": "Pink wading bird" },
-  { "word": "STORK", "clue": "Long-legged wading bird" },
-  { "word": "HERON", "clue": "Tall fishing bird" },
-  { "word": "CRANE", "clue": "Large wading bird" },
-  { "word": "SWAN", "clue": "Elegant white water bird" },
-  { "word": "GOOSE", "clue": "Large waterfowl" },
-  { "word": "TURKEY", "clue": "Large ground bird" },
-  { "word": "PHEASANT", "clue": "Colorful game bird" },
-  { "word": "QUAIL", "clue": "Small ground bird" },
-  { "word": "PEACOCK", "clue": "Bird with spectacular tail feathers" },
-  { "word": "OSTRICH", "clue": "Largest flightless bird" },
-  { "word": "EMU", "clue": "Australian flightless bird" },
-  { "word": "KIWI", "clue": "Small flightless New Zealand bird" },
-  { "word": "PARROT", "clue": "Colorful talking bird" },
-  { "word": "TOUCAN", "clue": "Large-billed tropical bird" },
-  { "word": "MACAW", "clue": "Large colorful parrot" },
-  { "word": "COCKATOO", "clue": "Crested parrot" },
-  { "word": "CANARY", "clue": "Yellow singing bird" },
-  { "word": "FINCH", "clue": "Small seed-eating bird" },
-  { "word": "PIGEON", "clue": "Common city bird" },
-  { "word": "DOVE", "clue": "Symbol of peace" },
-  { "word": "SEAGULL", "clue": "Coastal scavenging bird" },
-  { "word": "ALBATROSS", "clue": "Large ocean bird" },
-  { "word": "PUFFIN", "clue": "Colorful-billed seabird" },
-  { "word": "LIZARD", "clue": "Small scaly reptile" },
-  { "word": "IGUANA", "clue": "Large tropical lizard" },
-  { "word": "GECKO", "clue": "Wall-climbing lizard" },
-  { "word": "CHAMELEON", "clue": "Color-changing reptile" },
-  { "word": "ALLIGATOR", "clue": "Large American crocodilian" },
-  { "word": "CROCODILE", "clue": "Large aquatic reptile" },
-  { "word": "PYTHON", "clue": "Large constricting snake" },
-  { "word": "COBRA", "clue": "Venomous hooded snake" },
-  { "word": "VIPER", "clue": "Poisonous snake" },
-  { "word": "RATTLESNAKE", "clue": "Snake with warning tail" },
-  { "word": "SALAMANDER", "clue": "Amphibian that can regrow limbs" },
-  { "word": "NEWT", "clue": "Small aquatic salamander" },
-  { "word": "TOAD", "clue": "Warty amphibian" },
-  { "word": "TADPOLE", "clue": "Frog larva" },
-  { "word": "SALMON", "clue": "Fish that swims upstream" },
-  { "word": "TROUT", "clue": "Freshwater game fish" },
-  { "word": "BASS", "clue": "Popular sport fish" },
-  { "word": "TUNA", "clue": "Large ocean fish" },
-  { "word": "SWORDFISH", "clue": "Fish with long pointed bill" },
-  { "word": "MARLIN", "clue": "Large billfish" },
-  { "word": "MANTA", "clue": "Large ray fish" },
-  { "word": "STINGRAY", "clue": "Flat fish with barbed tail" },
-  { "word": "EEL", "clue": "Snake-like fish" },
-  { "word": "SEAHORSE", "clue": "Horse-shaped fish" },
-  { "word": "ANGELFISH", "clue": "Colorful tropical fish" },
-  { "word": "GOLDFISH", "clue": "Common pet fish" },
-  { "word": "CLOWNFISH", "clue": "Orange and white anemone fish" },
-  { "word": "JELLYFISH", "clue": "Transparent stinging sea creature" },
-  { "word": "OCTOPUS", "clue": "Eight-armed sea creature" },
-  { "word": "SQUID", "clue": "Ten-armed cephalopod" },
-  { "word": "CRAB", "clue": "Sideways-walking crustacean" },
-  { "word": "LOBSTER", "clue": "Large marine crustacean" },
-  { "word": "SHRIMP", "clue": "Small crustacean" },
-  { "word": "STARFISH", "clue": "Five-armed sea creature" },
-  { "word": "URCHIN", "clue": "Spiny sea creature" },
-  { "word": "CORAL", "clue": "Marine organism that builds reefs" },
-  { "word": "SPONGE", "clue": "Simple marine animal" },
-  { "word": "OYSTER", "clue": "Pearl-producing mollusk" },
-  { "word": "CLAM", "clue": "Burrowing shellfish" },
-  { "word": "MUSSEL", "clue": "Dark-shelled mollusk" },
-  { "word": "SNAIL", "clue": "Spiral-shelled gastropod" },
-  { "word": "SLUG", "clue": "Shell-less gastropod" },
-  { "word": "WORM", "clue": "Segmented invertebrate" },
-  { "word": "SPIDER", "clue": "Eight-legged web spinner" },
-  { "word": "SCORPION", "clue": "Arachnid with stinging tail" },
-  { "word": "ANT", "clue": "Social insect worker" },
-  { "word": "BEE", "clue": "Honey-making insect" },
-  { "word": "WASP", "clue": "Stinging flying insect" },
-  { "word": "HORNET", "clue": "Large aggressive wasp" },
-  { "word": "FLY", "clue": "Common buzzing insect" },
-  { "word": "MOSQUITO", "clue": "Blood-sucking insect" },
-  { "word": "BEETLE", "clue": "Hard-shelled insect" },
-  { "word": "LADYBUG", "clue": "Red spotted beneficial insect" },
-  { "word": "DRAGONFLY", "clue": "Large-winged flying insect" },
-  { "word": "GRASSHOPPER", "clue": "Jumping green insect" },
-  { "word": "CRICKET", "clue": "Chirping insect" },
-  { "word": "MANTIS", "clue": "Praying insect predator" },
-  { "word": "MOTH", "clue": "Nocturnal butterfly relative" },
-  { "word": "CATERPILLAR", "clue": "Butterfly larva" },
-  { "word": "COCOON", "clue": "Insect transformation casing" },
-  { "word": "TERMITE", "clue": "Wood-eating social insect" },
-  { "word": "TICK", "clue": "Blood-sucking parasite" },
-  { "word": "FLEA", "clue": "Jumping parasite" },
-  { "word": "LOUSE", "clue": "Small parasitic insect" },
-  { "word": "APHID", "clue": "Plant-sucking insect" },
-  { "word": "MAGGOT", "clue": "Fly larva" },
-  { "word": "GRUB", "clue": "Beetle larva" }
-]

crossword-app/backend/data/word-lists/geography.json

@@ -1,161 +0,0 @@
-[
-  { "word": "MOUNTAIN", "clue": "High elevation landform" },
-  { "word": "OCEAN", "clue": "Large body of salt water" },
-  { "word": "DESERT", "clue": "Dry, arid region" },
-  { "word": "CONTINENT", "clue": "Large landmass" },
-  { "word": "RIVER", "clue": "Flowing body of water" },
-  { "word": "ISLAND", "clue": "Land surrounded by water" },
-  { "word": "FOREST", "clue": "Dense area of trees" },
-  { "word": "VALLEY", "clue": "Low area between hills" },
-  { "word": "LAKE", "clue": "Body of freshwater" },
-  { "word": "BEACH", "clue": "Sandy shore by water" },
-  { "word": "CLIFF", "clue": "Steep rock face" },
-  { "word": "PLATEAU", "clue": "Elevated flat area" },
-  { "word": "CANYON", "clue": "Deep gorge with steep sides" },
-  { "word": "GLACIER", "clue": "Moving mass of ice" },
-  { "word": "VOLCANO", "clue": "Mountain that erupts" },
-  { "word": "PENINSULA", "clue": "Land surrounded by water on three sides" },
-  { "word": "ARCHIPELAGO", "clue": "Group of islands" },
-  { "word": "PRAIRIE", "clue": "Grassland plain" },
-  { "word": "TUNDRA", "clue": "Cold, treeless region" },
-  { "word": "SAVANNA", "clue": "Tropical grassland" },
-  { "word": "EQUATOR", "clue": "Earth's middle line" },
-  { "word": "LATITUDE", "clue": "Distance from equator" },
-  { "word": "LONGITUDE", "clue": "Distance from prime meridian" },
-  { "word": "CLIMATE", "clue": "Long-term weather pattern" },
-  { "word": "MONSOON", "clue": "Seasonal wind pattern" },
-  { "word": "CAPITAL", "clue": "Main city of country" },
-  { "word": "BORDER", "clue": "Boundary between countries" },
-  { "word": "COAST", "clue": "Land meeting the sea" },
-  { "word": "STRAIT", "clue": "Narrow water passage" },
-  { "word": "DELTA", "clue": "River mouth formation" },
-  { "word": "FJORD", "clue": "Narrow inlet between cliffs" },
-  { "word": "ATOLL", "clue": "Ring-shaped coral island" },
-  { "word": "MESA", "clue": "Flat-topped hill" },
-  { "word": "BUTTE", "clue": "Isolated hill with steep sides" },
-  { "word": "GORGE", "clue": "Deep narrow valley" },
-  { "word": "RAVINE", "clue": "Small narrow gorge" },
-  { "word": "RIDGE", "clue": "Long narrow hilltop" },
-  { "word": "PEAK", "clue": "Mountain summit" },
-  { "word": "SUMMIT", "clue": "Highest point" },
-  { "word": "FOOTHILLS", "clue": "Hills at base of mountains" },
-  { "word": "RANGE", "clue": "Chain of mountains" },
-  { "word": "BASIN", "clue": "Low-lying area" },
-  { "word": "WATERSHED", "clue": "Drainage area" },
-  { "word": "ESTUARY", "clue": "Where river meets sea" },
-  { "word": "BAY", "clue": "Curved inlet of water" },
-  { "word": "GULF", "clue": "Large bay" },
-  { "word": "CAPE", "clue": "Point of land into water" },
-  { "word": "HEADLAND", "clue": "High point of land" },
-  { "word": "LAGOON", "clue": "Shallow coastal body of water" },
-  { "word": "REEF", "clue": "Underwater rock formation" },
-  { "word": "SHOAL", "clue": "Shallow area in water" },
-  { "word": "CHANNEL", "clue": "Deep water passage" },
-  { "word": "SOUND", "clue": "Large sea inlet" },
-  { "word": "HARBOR", "clue": "Sheltered port area" },
-  { "word": "INLET", "clue": "Small bay" },
-  { "word": "COVE", "clue": "Small sheltered bay" },
-  { "word": "MARSH", "clue": "Wetland area" },
-  { "word": "SWAMP", "clue": "Forested wetland" },
-  { "word": "BOG", "clue": "Acidic wetland" },
-  { "word": "OASIS", "clue": "Fertile spot in desert" },
-  { "word": "DUNE", "clue": "Sand hill" },
-  { "word": "PLAIN", "clue": "Flat grassland" },
-  { "word": "STEPPE", "clue": "Dry grassland" },
-  { "word": "TAIGA", "clue": "Northern coniferous forest" },
-  { "word": "RAINFOREST", "clue": "Dense tropical forest" },
-  { "word": "JUNGLE", "clue": "Dense tropical vegetation" },
-  { "word": "WOODLAND", "clue": "Area with scattered trees" },
-  { "word": "GROVE", "clue": "Small group of trees" },
-  { "word": "MEADOW", "clue": "Grassy field" },
-  { "word": "PASTURE", "clue": "Grazing land" },
-  { "word": "FIELD", "clue": "Open area of land" },
-  { "word": "MOOR", "clue": "Open uncultivated land" },
-  { "word": "HEATH", "clue": "Shrubland area" },
-  { "word": "ARCTIC", "clue": "Cold northern region" },
-  { "word": "ANTARCTIC", "clue": "Cold southern region" },
-  { "word": "POLAR", "clue": "Of the poles" },
-  { "word": "TROPICAL", "clue": "Hot humid climate zone" },
-  { "word": "TEMPERATE", "clue": "Moderate climate zone" },
-  { "word": "ARID", "clue": "Very dry" },
-  { "word": "HUMID", "clue": "Moist air" },
-  { "word": "ALTITUDE", "clue": "Height above sea level" },
-  { "word": "ELEVATION", "clue": "Height of land" },
-  { "word": "TERRAIN", "clue": "Physical features of land" },
-  { "word": "TOPOGRAPHY", "clue": "Surface features of area" },
-  { "word": "GEOGRAPHY", "clue": "Study of Earth's features" },
-  { "word": "CARTOGRAPHY", "clue": "Map making" },
-  { "word": "MERIDIAN", "clue": "Longitude line" },
-  { "word": "PARALLEL", "clue": "Latitude line" },
-  { "word": "HEMISPHERE", "clue": "Half of Earth" },
-  { "word": "TROPICS", "clue": "Hot climate zone" },
-  { "word": "POLES", "clue": "Earth's endpoints" },
-  { "word": "AXIS", "clue": "Earth's rotation line" },
-  { "word": "ORBIT", "clue": "Path around sun" },
-  { "word": "SEASON", "clue": "Time of year" },
-  { "word": "SOLSTICE", "clue": "Longest or shortest day" },
-  { "word": "EQUINOX", "clue": "Equal day and night" },
-  { "word": "COMPASS", "clue": "Direction-finding tool" },
-  { "word": "NAVIGATION", "clue": "Finding your way" },
-  { "word": "BEARING", "clue": "Direction or course" },
-  { "word": "AZIMUTH", "clue": "Compass direction" },
-  { "word": "SCALE", "clue": "Map size ratio" },
-  { "word": "LEGEND", "clue": "Map symbol key" },
-  { "word": "CONTOUR", "clue": "Elevation line on map" },
-  { "word": "GRID", "clue": "Map reference system" },
-  { "word": "PROJECTION", "clue": "Map flattening method" },
-  { "word": "SURVEY", "clue": "Land measurement" },
-  { "word": "BOUNDARY", "clue": "Dividing line" },
-  { "word": "FRONTIER", "clue": "Border region" },
-  { "word": "TERRITORY", "clue": "Area of land" },
-  { "word": "REGION", "clue": "Geographic area" },
-  { "word": "ZONE", "clue": "Designated area" },
-  { "word": "DISTRICT", "clue": "Administrative area" },
-  { "word": "PROVINCE", "clue": "Political subdivision" },
-  { "word": "STATE", "clue": "Political entity" },
-  { "word": "COUNTY", "clue": "Local government area" },
-  { "word": "CITY", "clue": "Large urban area" },
-  { "word": "TOWN", "clue": "Small urban area" },
-  { "word": "VILLAGE", "clue": "Small rural community" },
-  { "word": "HAMLET", "clue": "Very small village" },
-  { "word": "SUBURB", "clue": "Residential area outside city" },
-  { "word": "URBAN", "clue": "City-like" },
-  { "word": "RURAL", "clue": "Countryside" },
-  { "word": "METROPOLITAN", "clue": "Large city area" },
-  { "word": "POPULATION", "clue": "Number of people" },
-  { "word": "DENSITY", "clue": "Crowdedness" },
-  { "word": "SETTLEMENT", "clue": "Place where people live" },
-  { "word": "COLONY", "clue": "Overseas territory" },
-  { "word": "NATION", "clue": "Country" },
-  { "word": "REPUBLIC", "clue": "Democratic state" },
-  { "word": "KINGDOM", "clue": "Monarchy" },
-  { "word": "EMPIRE", "clue": "Large political entity" },
-  { "word": "FEDERATION", "clue": "Union of states" },
-  { "word": "ALLIANCE", "clue": "Partnership of nations" },
-  { "word": "TREATY", "clue": "International agreement" },
-  { "word": "TRADE", "clue": "Commercial exchange" },
-  { "word": "EXPORT", "clue": "Goods sent abroad" },
-  { "word": "IMPORT", "clue": "Goods brought in" },
-  { "word": "COMMERCE", "clue": "Business activity" },
-  { "word": "INDUSTRY", "clue": "Manufacturing" },
-  { "word": "AGRICULTURE", "clue": "Farming" },
-  { "word": "MINING", "clue": "Extracting minerals" },
-  { "word": "FORESTRY", "clue": "Tree management" },
-  { "word": "FISHING", "clue": "Catching fish" },
-  { "word": "TOURISM", "clue": "Travel industry" },
-  { "word": "TRANSPORTATION", "clue": "Moving people and goods" },
-  { "word": "INFRASTRUCTURE", "clue": "Basic facilities" },
-  { "word": "COMMUNICATION", "clue": "Information exchange" },
-  { "word": "CULTURE", "clue": "Way of life" },
-  { "word": "LANGUAGE", "clue": "Communication system" },
-  { "word": "RELIGION", "clue": "Belief system" },
-  { "word": "ETHNICITY", "clue": "Cultural group" },
-  { "word": "MIGRATION", "clue": "Movement of people" },
-  { "word": "IMMIGRATION", "clue": "Moving into country" },
-  { "word": "EMIGRATION", "clue": "Moving out of country" },
-  { "word": "DIASPORA", "clue": "Scattered population" },
-  { "word": "NOMAD", "clue": "Wandering person" },
-  { "word": "REFUGEE", "clue": "Displaced person" },
-  { "word": "CENSUS", "clue": "Population count" },
-  { "word": "DEMOGRAPHIC", "clue": "Population characteristic" }
-]

crossword-app/backend/data/word-lists/science.json

@@ -1,170 +0,0 @@
-[
-  { "word": "ATOM", "clue": "Smallest unit of matter" },
-  { "word": "GRAVITY", "clue": "Force that pulls objects down" },
-  { "word": "MOLECULE", "clue": "Group of atoms bonded together" },
-  { "word": "PHOTON", "clue": "Particle of light" },
-  { "word": "CHEMISTRY", "clue": "Study of matter and reactions" },
-  { "word": "PHYSICS", "clue": "Study of matter and energy" },
-  { "word": "BIOLOGY", "clue": "Study of living organisms" },
-  { "word": "ELEMENT", "clue": "Pure chemical substance" },
-  { "word": "OXYGEN", "clue": "Gas essential for breathing" },
-  { "word": "CARBON", "clue": "Element found in all life" },
-  { "word": "HYDROGEN", "clue": "Lightest chemical element" },
-  { "word": "ENERGY", "clue": "Capacity to do work" },
-  { "word": "FORCE", "clue": "Push or pull on an object" },
-  { "word": "VELOCITY", "clue": "Speed with direction" },
-  { "word": "MASS", "clue": "Amount of matter in object" },
-  { "word": "VOLUME", "clue": "Amount of space occupied" },
-  { "word": "DENSITY", "clue": "Mass per unit volume" },
-  { "word": "PRESSURE", "clue": "Force per unit area" },
-  { "word": "TEMPERATURE", "clue": "Measure of heat" },
-  { "word": "ELECTRON", "clue": "Negatively charged particle" },
-  { "word": "PROTON", "clue": "Positively charged particle" },
-  { "word": "NEUTRON", "clue": "Neutral atomic particle" },
-  { "word": "NUCLEUS", "clue": "Center of an atom" },
-  { "word": "CELL", "clue": "Basic unit of life" },
-  { "word": "DNA", "clue": "Genetic blueprint molecule" },
-  { "word": "PROTEIN", "clue": "Complex biological molecule" },
-  { "word": "ENZYME", "clue": "Biological catalyst" },
-  { "word": "VIRUS", "clue": "Infectious agent" },
-  { "word": "BACTERIA", "clue": "Single-celled organisms" },
-  { "word": "EVOLUTION", "clue": "Change in species over time" },
-  { "word": "ISOTOPE", "clue": "Atom variant with different neutrons" },
-  { "word": "ION", "clue": "Charged atom or molecule" },
-  { "word": "COMPOUND", "clue": "Chemical combination of elements" },
-  { "word": "MIXTURE", "clue": "Combined substances retaining properties" },
-  { "word": "SOLUTION", "clue": "Dissolved mixture" },
-  { "word": "ACID", "clue": "Sour chemical with low pH" },
-  { "word": "BASE", "clue": "Alkaline substance with high pH" },
-  { "word": "SALT", "clue": "Ionic compound from acid-base reaction" },
-  { "word": "CATALYST", "clue": "Substance that speeds reactions" },
-  { "word": "RNA", "clue": "Genetic messenger molecule" },
-  { "word": "GENE", "clue": "Heredity unit on chromosome" },
-  { "word": "CHROMOSOME", "clue": "Gene-carrying structure" },
-  { "word": "TISSUE", "clue": "Group of similar cells" },
-  { "word": "ORGAN", "clue": "Body part with specific function" },
-  { "word": "SYSTEM", "clue": "Group of organs working together" },
-  { "word": "ORGANISM", "clue": "Living individual entity" },
-  { "word": "SPECIES", "clue": "Group of similar organisms" },
-  { "word": "ADAPTATION", "clue": "Survival-enhancing change" },
-  { "word": "MUTATION", "clue": "Genetic change in DNA" },
-  { "word": "HEREDITY", "clue": "Passing traits to offspring" },
-  { "word": "ECOSYSTEM", "clue": "Community and environment" },
-  { "word": "HABITAT", "clue": "Natural living environment" },
-  { "word": "BIODIVERSITY", "clue": "Variety of life forms" },
-  { "word": "PHOTOSYNTHESIS", "clue": "Plant energy-making process" },
-  { "word": "RESPIRATION", "clue": "Cellular breathing process" },
-  { "word": "METABOLISM", "clue": "Chemical processes in body" },
-  { "word": "HOMEOSTASIS", "clue": "Body's internal balance" },
-  { "word": "MITOSIS", "clue": "Cell division for growth" },
-  { "word": "MEIOSIS", "clue": "Cell division for reproduction" },
-  { "word": "EMBRYO", "clue": "Early development stage" },
-  { "word": "FOSSIL", "clue": "Preserved ancient remains" },
-  { "word": "GEOLOGY", "clue": "Study of Earth's structure" },
-  { "word": "MINERAL", "clue": "Natural inorganic crystal" },
-  { "word": "ROCK", "clue": "Solid earth material" },
-  { "word": "SEDIMENT", "clue": "Settled particles" },
-  { "word": "EROSION", "clue": "Gradual wearing away" },
-  { "word": "VOLCANO", "clue": "Earth opening spewing lava" },
-  { "word": "EARTHQUAKE", "clue": "Ground shaking from plate movement" },
-  { "word": "PLATE", "clue": "Earth's crust section" },
-  { "word": "MAGMA", "clue": "Molten rock beneath surface" },
-  { "word": "LAVA", "clue": "Molten rock on surface" },
-  { "word": "CRYSTAL", "clue": "Ordered atomic structure" },
-  { "word": "ATMOSPHERE", "clue": "Layer of gases around Earth" },
-  { "word": "CLIMATE", "clue": "Long-term weather pattern" },
-  { "word": "WEATHER", "clue": "Short-term atmospheric conditions" },
-  { "word": "PRECIPITATION", "clue": "Water falling from clouds" },
-  { "word": "HUMIDITY", "clue": "Moisture in air" },
-  { "word": "WIND", "clue": "Moving air mass" },
-  { "word": "STORM", "clue": "Violent weather event" },
-  { "word": "HURRICANE", "clue": "Powerful tropical cyclone" },
-  { "word": "TORNADO", "clue": "Rotating column of air" },
-  { "word": "LIGHTNING", "clue": "Electrical discharge in sky" },
-  { "word": "THUNDER", "clue": "Sound of lightning" },
-  { "word": "RAINBOW", "clue": "Spectrum of light in sky" },
-  { "word": "ASTRONOMY", "clue": "Study of celestial objects" },
-  { "word": "GALAXY", "clue": "Collection of stars and planets" },
-  { "word": "PLANET", "clue": "Large orbiting celestial body" },
-  { "word": "STAR", "clue": "Self-luminous celestial body" },
-  { "word": "MOON", "clue": "Natural satellite of planet" },
-  { "word": "COMET", "clue": "Icy body with tail" },
-  { "word": "ASTEROID", "clue": "Rocky space object" },
-  { "word": "METEOR", "clue": "Space rock entering atmosphere" },
-  { "word": "ORBIT", "clue": "Curved path around object" },
-  { "word": "LIGHT", "clue": "Electromagnetic radiation" },
-  { "word": "SPECTRUM", "clue": "Range of electromagnetic radiation" },
-  { "word": "WAVELENGTH", "clue": "Distance between wave peaks" },
-  { "word": "FREQUENCY", "clue": "Waves per unit time" },
-  { "word": "AMPLITUDE", "clue": "Wave height or intensity" },
-  { "word": "SOUND", "clue": "Vibrations in air" },
-  { "word": "ECHO", "clue": "Reflected sound" },
-  { "word": "RESONANCE", "clue": "Vibration amplification" },
-  { "word": "DOPPLER", "clue": "Wave frequency shift effect" },
-  { "word": "MOTION", "clue": "Change in position" },
-  { "word": "ACCELERATION", "clue": "Change in velocity" },
-  { "word": "MOMENTUM", "clue": "Mass times velocity" },
-  { "word": "INERTIA", "clue": "Resistance to motion change" },
-  { "word": "FRICTION", "clue": "Resistance to sliding" },
-  { "word": "HEAT", "clue": "Thermal energy transfer" },
-  { "word": "COMBUSTION", "clue": "Burning chemical reaction" },
-  { "word": "OXIDATION", "clue": "Reaction with oxygen" },
-  { "word": "REDUCTION", "clue": "Gain of electrons" },
-  { "word": "ELECTROLYSIS", "clue": "Chemical breakdown by electricity" },
-  { "word": "CONDUCTIVITY", "clue": "Ability to transfer energy" },
-  { "word": "INSULATOR", "clue": "Material blocking energy flow" },
-  { "word": "SEMICONDUCTOR", "clue": "Partial electrical conductor" },
-  { "word": "MAGNETISM", "clue": "Force of magnetic attraction" },
-  { "word": "FIELD", "clue": "Region of force influence" },
-  { "word": "CIRCUIT", "clue": "Closed electrical path" },
-  { "word": "CURRENT", "clue": "Flow of electric charge" },
-  { "word": "VOLTAGE", "clue": "Electric potential difference" },
-  { "word": "RESISTANCE", "clue": "Opposition to current flow" },
-  { "word": "CAPACITOR", "clue": "Device storing electric charge" },
-  { "word": "INDUCTOR", "clue": "Device storing magnetic energy" },
-  { "word": "TRANSISTOR", "clue": "Electronic switching device" },
-  { "word": "LASER", "clue": "Focused beam of light" },
-  { "word": "RADAR", "clue": "Radio detection system" },
-  { "word": "SONAR", "clue": "Sound detection system" },
-  { "word": "TELESCOPE", "clue": "Instrument for viewing distant objects" },
-  { "word": "MICROSCOPE", "clue": "Instrument for viewing small objects" },
-  { "word": "HYPOTHESIS", "clue": "Testable scientific prediction" },
-  { "word": "THEORY", "clue": "Well-tested scientific explanation" },
-  { "word": "LAW", "clue": "Consistently observed scientific rule" },
-  { "word": "EXPERIMENT", "clue": "Controlled scientific test" },
-  { "word": "OBSERVATION", "clue": "Careful scientific watching" },
-  { "word": "MEASUREMENT", "clue": "Quantified observation" },
-  { "word": "ANALYSIS", "clue": "Detailed examination of data" },
-  { "word": "SYNTHESIS", "clue": "Combining elements into whole" },
-  { "word": "VARIABLE", "clue": "Factor that can change" },
-  { "word": "CONTROL", "clue": "Unchanged comparison group" },
-  { "word": "DATA", "clue": "Information collected from tests" },
-  { "word": "STATISTICS", "clue": "Mathematical analysis of data" },
-  { "word": "PROBABILITY", "clue": "Likelihood of occurrence" },
-  { "word": "PRECISION", "clue": "Exactness of measurement" },
-  { "word": "ACCURACY", "clue": "Correctness of measurement" },
-  { "word": "ERROR", "clue": "Difference from true value" },
-  { "word": "UNCERTAINTY", "clue": "Range of doubt in measurement" },
-  { "word": "CALIBRATION", "clue": "Adjusting instrument accuracy" },
-  { "word": "STANDARD", "clue": "Reference for measurement" },
-  { "word": "UNIT", "clue": "Base measure of quantity" },
-  { "word": "METRIC", "clue": "Decimal measurement system" },
-  { "word": "WEIGHT", "clue": "Force of gravity on mass" },
-  { "word": "CONCENTRATION", "clue": "Amount of substance per volume" },
-  { "word": "MOLARITY", "clue": "Moles of solute per liter" },
-  { "word": "EQUILIBRIUM", "clue": "State of balanced forces" },
-  { "word": "STABILITY", "clue": "Resistance to change" },
-  { "word": "DECAY", "clue": "Gradual breakdown process" },
-  { "word": "RADIATION", "clue": "Energy emitted from source" },
-  { "word": "RADIOACTIVE", "clue": "Emitting nuclear radiation" },
-  { "word": "HALFLIFE", "clue": "Time for half to decay" },
-  { "word": "FUSION", "clue": "Nuclear combining reaction" },
-  { "word": "FISSION", "clue": "Nuclear splitting reaction" },
-  { "word": "QUANTUM", "clue": "Discrete packet of energy" },
-  { "word": "PARTICLE", "clue": "Tiny piece of matter" },
-  { "word": "WAVE", "clue": "Energy transfer disturbance" },
-  { "word": "INTERFERENCE", "clue": "Wave interaction effect" },
-  { "word": "DIFFRACTION", "clue": "Wave bending around obstacle" },
-  { "word": "REFLECTION", "clue": "Bouncing back of waves" },
-  { "word": "REFRACTION", "clue": "Bending of waves through medium" }
-]

crossword-app/backend/data/word-lists/technology.json

@@ -1,221 +0,0 @@
-[
-  { "word": "COMPUTER", "clue": "Electronic processing device" },
-  { "word": "INTERNET", "clue": "Global computer network" },
-  { "word": "ALGORITHM", "clue": "Set of rules for solving problems" },
-  { "word": "DATABASE", "clue": "Organized collection of data" },
-  { "word": "SOFTWARE", "clue": "Computer programs" },
-  { "word": "HARDWARE", "clue": "Physical computer components" },
-  { "word": "NETWORK", "clue": "Connected system of computers" },
-  { "word": "CODE", "clue": "Programming instructions" },
-  { "word": "ROBOT", "clue": "Automated machine" },
-  { "word": "ARTIFICIAL", "clue": "Made by humans, not natural" },
-  { "word": "DIGITAL", "clue": "Using binary data" },
-  { "word": "BINARY", "clue": "Base-2 number system" },
-  { "word": "PROCESSOR", "clue": "Computer's brain" },
-  { "word": "MEMORY", "clue": "Data storage component" },
-  { "word": "KEYBOARD", "clue": "Input device with keys" },
-  { "word": "MONITOR", "clue": "Computer display screen" },
-  { "word": "MOUSE", "clue": "Pointing input device" },
-  { "word": "PRINTER", "clue": "Device that prints documents" },
-  { "word": "SCANNER", "clue": "Device that digitizes images" },
-  { "word": "CAMERA", "clue": "Device that captures images" },
-  { "word": "SMARTPHONE", "clue": "Portable computing device" },
-  { "word": "TABLET", "clue": "Touchscreen computing device" },
-  { "word": "LAPTOP", "clue": "Portable computer" },
-  { "word": "SERVER", "clue": "Computer that serves data" },
-  { "word": "CLOUD", "clue": "Internet-based computing" },
-  { "word": "WEBSITE", "clue": "Collection of web pages" },
-  { "word": "EMAIL", "clue": "Electronic mail" },
-  { "word": "BROWSER", "clue": "Web navigation software" },
-  { "word": "SEARCH", "clue": "Look for information" },
-  { "word": "DOWNLOAD", "clue": "Transfer data to device" },
-  { "word": "UPLOAD", "clue": "Transfer data from device" },
-  { "word": "BANDWIDTH", "clue": "Data transfer capacity" },
-  { "word": "PROTOCOL", "clue": "Communication rules" },
-  { "word": "FIREWALL", "clue": "Network security barrier" },
-  { "word": "ENCRYPTION", "clue": "Data scrambling for security" },
-  { "word": "PASSWORD", "clue": "Secret access code" },
-  { "word": "SECURITY", "clue": "Protection from threats" },
-  { "word": "VIRUS", "clue": "Malicious computer program" },
-  { "word": "MALWARE", "clue": "Harmful software" },
-  { "word": "ANTIVIRUS", "clue": "Protection software" },
-  { "word": "BACKUP", "clue": "Data safety copy" },
-  { "word": "RECOVERY", "clue": "Data restoration process" },
-  { "word": "STORAGE", "clue": "Data keeping capacity" },
-  { "word": "HARDDRIVE", "clue": "Magnetic storage device" },
-  { "word": "FLASH", "clue": "Solid state storage" },
-  { "word": "RAM", "clue": "Random access memory" },
-  { "word": "ROM", "clue": "Read-only memory" },
-  { "word": "CPU", "clue": "Central processing unit" },
-  { "word": "GPU", "clue": "Graphics processing unit" },
-  { "word": "MOTHERBOARD", "clue": "Main circuit board" },
-  { "word": "CHIP", "clue": "Integrated circuit" },
-  { "word": "CIRCUIT", "clue": "Electronic pathway" },
-  { "word": "TRANSISTOR", "clue": "Electronic switch" },
-  { "word": "SILICON", "clue": "Semiconductor material" },
-  { "word": "NANOTECHNOLOGY", "clue": "Extremely small scale tech" },
-  { "word": "AUTOMATION", "clue": "Self-operating technology" },
-  { "word": "MACHINE", "clue": "Mechanical device" },
-  { "word": "SENSOR", "clue": "Detection device" },
-  { "word": "ACTUATOR", "clue": "Movement device" },
-  { "word": "FEEDBACK", "clue": "System response information" },
-  { "word": "PROGRAMMING", "clue": "Writing computer instructions" },
-  { "word": "FUNCTION", "clue": "Reusable code block" },
-  { "word": "VARIABLE", "clue": "Data storage container" },
-  { "word": "LOOP", "clue": "Repeating code structure" },
-  { "word": "CONDITION", "clue": "Decision-making logic" },
-  { "word": "DEBUG", "clue": "Find and fix errors" },
-  { "word": "COMPILE", "clue": "Convert code to executable" },
-  { "word": "RUNTIME", "clue": "Program execution time" },
-  { "word": "API", "clue": "Application programming interface" },
-  { "word": "FRAMEWORK", "clue": "Code structure foundation" },
-  { "word": "LIBRARY", "clue": "Reusable code collection" },
-  { "word": "MODULE", "clue": "Self-contained code unit" },
-  { "word": "OBJECT", "clue": "Data and methods container" },
-  { "word": "CLASS", "clue": "Object blueprint" },
-  { "word": "INHERITANCE", "clue": "Code reuse mechanism" },
-  { "word": "INTERFACE", "clue": "System interaction boundary" },
-  { "word": "PROTOCOL", "clue": "Communication standard" },
-  { "word": "FORMAT", "clue": "Data structure standard" },
-  { "word": "SYNTAX", "clue": "Language rules" },
-  { "word": "SEMANTIC", "clue": "Meaning in code" },
-  { "word": "PARSING", "clue": "Analyzing code structure" },
-  { "word": "COMPILER", "clue": "Code translation program" },
-  { "word": "INTERPRETER", "clue": "Code execution program" },
-  { "word": "VIRTUAL", "clue": "Simulated environment" },
-  { "word": "SIMULATION", "clue": "Computer modeling" },
-  { "word": "EMULATION", "clue": "System imitation" },
-  { "word": "OPTIMIZATION", "clue": "Performance improvement" },
-  { "word": "EFFICIENCY", "clue": "Resource usage effectiveness" },
-  { "word": "PERFORMANCE", "clue": "System speed and quality" },
-  { "word": "BENCHMARK", "clue": "Performance measurement" },
-  { "word": "TESTING", "clue": "Quality verification process" },
-  { "word": "VALIDATION", "clue": "Correctness checking" },
-  { "word": "VERIFICATION", "clue": "Accuracy confirmation" },
-  { "word": "QUALITY", "clue": "Standard of excellence" },
-  { "word": "MAINTENANCE", "clue": "System upkeep" },
-  { "word": "UPDATE", "clue": "Software improvement" },
-  { "word": "PATCH", "clue": "Software fix" },
-  { "word": "VERSION", "clue": "Software release number" },
-  { "word": "RELEASE", "clue": "Software distribution" },
-  { "word": "DEPLOYMENT", "clue": "Software installation" },
-  { "word": "CONFIGURATION", "clue": "System setup" },
-  { "word": "INSTALLATION", "clue": "Software setup process" },
-  { "word": "MIGRATION", "clue": "System transition" },
-  { "word": "INTEGRATION", "clue": "System combination" },
-  { "word": "COMPATIBILITY", "clue": "System cooperation ability" },
-  { "word": "INTEROPERABILITY", "clue": "Cross-system communication" },
-  { "word": "SCALABILITY", "clue": "Growth accommodation ability" },
-  { "word": "RELIABILITY", "clue": "Consistent performance" },
-  { "word": "AVAILABILITY", "clue": "System accessibility" },
-  { "word": "REDUNDANCY", "clue": "Backup system duplication" },
-  { "word": "FAULT", "clue": "System error condition" },
-  { "word": "TOLERANCE", "clue": "Error handling ability" },
-  { "word": "RECOVERY", "clue": "System restoration" },
-  { "word": "MONITORING", "clue": "System observation" },
-  { "word": "LOGGING", "clue": "Event recording" },
-  { "word": "ANALYTICS", "clue": "Data analysis" },
-  { "word": "METRICS", "clue": "Measurement data" },
-  { "word": "DASHBOARD", "clue": "Information display panel" },
-  { "word": "INTERFACE", "clue": "User interaction design" },
-  { "word": "EXPERIENCE", "clue": "User interaction quality" },
-  { "word": "USABILITY", "clue": "Ease of use" },
-  { "word": "ACCESSIBILITY", "clue": "Universal design principle" },
-  { "word": "RESPONSIVE", "clue": "Adaptive design" },
-  { "word": "MOBILE", "clue": "Portable device category" },
-  { "word": "TOUCHSCREEN", "clue": "Touch-sensitive display" },
-  { "word": "GESTURE", "clue": "Touch movement command" },
-  { "word": "VOICE", "clue": "Speech interaction" },
-  { "word": "RECOGNITION", "clue": "Pattern identification" },
-  { "word": "LEARNING", "clue": "Adaptive improvement" },
-  { "word": "INTELLIGENCE", "clue": "Artificial reasoning" },
-  { "word": "NEURAL", "clue": "Brain-inspired network" },
-  { "word": "DEEP", "clue": "Multi-layered learning" },
-  { "word": "MACHINE", "clue": "Automated learning system" },
-  { "word": "DATA", "clue": "Information collection" },
-  { "word": "BIG", "clue": "Large scale data" },
-  { "word": "MINING", "clue": "Data pattern extraction" },
-  { "word": "ANALYSIS", "clue": "Data examination" },
-  { "word": "VISUALIZATION", "clue": "Data graphic representation" },
-  { "word": "DASHBOARD", "clue": "Data monitoring panel" },
-  { "word": "REPORT", "clue": "Data summary document" },
-  { "word": "QUERY", "clue": "Data search request" },
-  { "word": "INDEX", "clue": "Data location reference" },
-  { "word": "SCHEMA", "clue": "Data structure blueprint" },
-  { "word": "TABLE", "clue": "Data organization structure" },
-  { "word": "RECORD", "clue": "Data entry" },
-  { "word": "FIELD", "clue": "Data element" },
-  { "word": "PRIMARY", "clue": "Main identifier key" },
-  { "word": "FOREIGN", "clue": "Reference relationship key" },
-  { "word": "RELATION", "clue": "Data connection" },
-  { "word": "JOIN", "clue": "Data combination operation" },
-  { "word": "TRANSACTION", "clue": "Data operation sequence" },
-  { "word": "COMMIT", "clue": "Data change confirmation" },
-  { "word": "ROLLBACK", "clue": "Data change reversal" },
-  { "word": "CONCURRENCY", "clue": "Simultaneous access handling" },
-  { "word": "LOCK", "clue": "Data access control" },
-  { "word": "SYNCHRONIZATION", "clue": "Timing coordination" },
-  { "word": "THREAD", "clue": "Execution sequence" },
-  { "word": "PROCESS", "clue": "Running program instance" },
-  { "word": "MULTITASKING", "clue": "Multiple process handling" },
-  { "word": "PARALLEL", "clue": "Simultaneous execution" },
-  { "word": "DISTRIBUTED", "clue": "Spread across multiple systems" },
-  { "word": "CLUSTER", "clue": "Group of connected computers" },
-  { "word": "GRID", "clue": "Distributed computing network" },
-  { "word": "PEER", "clue": "Equal network participant" },
-  { "word": "CLIENT", "clue": "Service requesting system" },
-  { "word": "SERVICE", "clue": "System functionality provider" },
-  { "word": "MICROSERVICE", "clue": "Small independent service" },
-  { "word": "CONTAINER", "clue": "Isolated application environment" },
-  { "word": "DOCKER", "clue": "Containerization platform" },
-  { "word": "KUBERNETES", "clue": "Container orchestration" },
-  { "word": "DEVOPS", "clue": "Development operations practice" },
-  { "word": "AGILE", "clue": "Flexible development method" },
-  { "word": "SCRUM", "clue": "Iterative development framework" },
-  { "word": "SPRINT", "clue": "Short development cycle" },
-  { "word": "KANBAN", "clue": "Visual workflow management" },
-  { "word": "CONTINUOUS", "clue": "Ongoing integration practice" },
-  { "word": "PIPELINE", "clue": "Automated workflow" },
-  { "word": "BUILD", "clue": "Software compilation process" },
-  { "word": "TESTING", "clue": "Quality assurance process" },
-  { "word": "AUTOMATION", "clue": "Manual task elimination" },
-  { "word": "SCRIPT", "clue": "Automated task sequence" },
-  { "word": "BATCH", "clue": "Group processing" },
-  { "word": "STREAMING", "clue": "Continuous data flow" },
-  { "word": "REALTIME", "clue": "Immediate processing" },
-  { "word": "LATENCY", "clue": "Response delay time" },
-  { "word": "THROUGHPUT", "clue": "Processing capacity" },
-  { "word": "BOTTLENECK", "clue": "Performance limitation point" },
-  { "word": "CACHE", "clue": "Fast temporary storage" },
-  { "word": "BUFFER", "clue": "Temporary data holder" },
-  { "word": "QUEUE", "clue": "Ordered waiting line" },
-  { "word": "STACK", "clue": "Last-in-first-out structure" },
-  { "word": "HEAP", "clue": "Dynamic memory area" },
-  { "word": "POINTER", "clue": "Memory address reference" },
-  { "word": "REFERENCE", "clue": "Object location indicator" },
-  { "word": "GARBAGE", "clue": "Unused memory collection" },
-  { "word": "ALLOCATION", "clue": "Memory assignment" },
-  { "word": "DEALLOCATION", "clue": "Memory release" },
-  { "word": "LEAK", "clue": "Memory usage error" },
-  { "word": "OVERFLOW", "clue": "Capacity exceeding error" },
-  { "word": "UNDERFLOW", "clue": "Insufficient data error" },
-  { "word": "EXCEPTION", "clue": "Error handling mechanism" },
-  { "word": "INTERRUPT", "clue": "Process suspension signal" },
-  { "word": "SIGNAL", "clue": "Process communication" },
-  { "word": "EVENT", "clue": "System occurrence" },
-  { "word": "HANDLER", "clue": "Event processing function" },
-  { "word": "CALLBACK", "clue": "Function reference" },
-  { "word": "PROMISE", "clue": "Future value placeholder" },
-  { "word": "ASYNC", "clue": "Non-blocking operation" },
-  { "word": "AWAIT", "clue": "Pause for completion" },
-  { "word": "YIELD", "clue": "Temporary function pause" },
-  { "word": "GENERATOR", "clue": "Value sequence producer" },
-  { "word": "ITERATOR", "clue": "Sequential access pattern" },
-  { "word": "RECURSION", "clue": "Self-calling function" },
-  { "word": "CLOSURE", "clue": "Function scope retention" },
-  { "word": "LAMBDA", "clue": "Anonymous function" },
-  { "word": "FUNCTIONAL", "clue": "Function-based programming" },
-  { "word": "PROCEDURAL", "clue": "Step-by-step programming" },
-  { "word": "DECLARATIVE", "clue": "What-not-how programming" },
-  { "word": "IMPERATIVE", "clue": "Command-based programming" }
-]

crossword-app/backend/package.json

@@ -1,53 +0,0 @@
-{
-  "name": "crossword-backend",
-  "version": "1.0.0",
-  "description": "Node.js backend for crossword puzzle generator",
-  "main": "src/app.js",
-  "type": "commonjs",
-  "scripts": {
-    "start": "node src/app.js",
-    "dev": "nodemon src/app.js",
-    "build:frontend": "cd ../frontend && npm run build",
-    "build": "npm run build:frontend && mkdir -p public && cp -r ../frontend/dist/* public/",
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "lint": "eslint src/",
-    "lint:fix": "eslint src/ --fix",
-    "format": "prettier --write \"src/**/*.js\"",
-    "db:migrate": "node scripts/migrate.js",
-    "db:seed": "node scripts/seed.js",
-    "db:reset": "npm run db:migrate && npm run db:seed"
-  },
-  "dependencies": {
-    "@huggingface/inference": "^4.7.1",
-    "compression": "^1.7.4",
-    "cors": "^2.8.5",
-    "dotenv": "^16.3.1",
-    "express": "^4.18.2",
-    "express-rate-limit": "^7.1.5",
-    "helmet": "^7.1.0",
-    "pg": "^8.11.3"
-  },
-  "devDependencies": {
-    "axios": "^1.11.0",
-    "eslint": "^8.55.0",
-    "jest": "^29.7.0",
-    "nodemon": "^3.0.2",
-    "prettier": "^3.1.1",
-    "supertest": "^6.3.3"
-  },
-  "engines": {
-    "node": ">=18.0.0",
-    "npm": ">=9.0.0"
-  },
-  "keywords": [
-    "crossword",
-    "puzzle",
-    "word-game",
-    "api",
-    "nodejs",
-    "express"
-  ],
-  "author": "Crossword App Team",
-  "license": "MIT"
-}

crossword-app/backend/public/assets/index-Bkj8ir_U.js

@@ -1,10 +0,0 @@
-import{r as m,a as R,R as k}from"./vendor-nf7bT_Uh.js";(function(){const c=document.createElement("link").relList;if(c&&c.supports&&c.supports("modulepreload"))return;for(const s of document.querySelectorAll('link[rel="modulepreload"]'))n(s);new MutationObserver(s=>{for(const r of s)if(r.type==="childList")for(const a of r.addedNodes)a.tagName==="LINK"&&a.rel==="modulepreload"&&n(a)}).observe(document,{childList:!0,subtree:!0});function i(s){const r={};return s.integrity&&(r.integrity=s.integrity),s.referrerPolicy&&(r.referrerPolicy=s.referrerPolicy),s.crossOrigin==="use-credentials"?r.credentials="include":s.crossOrigin==="anonymous"?r.credentials="omit":r.credentials="same-origin",r}function n(s){if(s.ep)return;s.ep=!0;const r=i(s);fetch(s.href,r)}})();var S={exports:{}},b={};/**
- * @license React
- * react-jsx-runtime.production.min.js
- *
- * Copyright (c) Facebook, Inc. and its affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */var E=m,_=Symbol.for("react.element"),$=Symbol.for("react.fragment"),T=Object.prototype.hasOwnProperty,O=E.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner,A={key:!0,ref:!0,__self:!0,__source:!0};function C(t,c,i){var n,s={},r=null,a=null;i!==void 0&&(r=""+i),c.key!==void 0&&(r=""+c.key),c.ref!==void 0&&(a=c.ref);for(n in c)T.call(c,n)&&!A.hasOwnProperty(n)&&(s[n]=c[n]);if(t&&t.defaultProps)for(n in c=t.defaultProps,c)s[n]===void 0&&(s[n]=c[n]);return{$$typeof:_,type:t,key:r,ref:a,props:s,_owner:O.current}}b.Fragment=$;b.jsx=C;b.jsxs=C;S.exports=b;var e=S.exports,v={},w=R;v.createRoot=w.createRoot,v.hydrateRoot=w.hydrateRoot;const L=({onTopicsChange:t,availableTopics:c=[],selectedTopics:i=[],useAI:n=!1,onAIToggle:s})=>{const r=a=>{const g=i.includes(a)?i.filter(o=>o!==a):[...i,a];t(g)};return e.jsxs("div",{className:"topic-selector",children:[e.jsx("h3",{children:"Select Topics"}),e.jsx("div",{className:"topic-buttons",children:c.map(a=>e.jsx("button",{className:`topic-btn ${i.includes(a.name)?"selected":""}`,onClick:()=>r(a.name),children:a.name},a.id))}),e.jsxs("div",{className:"ai-toggle-container",children:[e.jsxs("label",{className:"ai-toggle",children:[e.jsx("input",{type:"checkbox",checked:n,onChange:a=>s(a.target.checked),className:"ai-checkbox"}),e.jsxs("span",{className:"ai-label",children:["🤖 Use AI-powered word generation",n&&e.jsx("span",{className:"ai-status",children:" (Dynamic content)"})]})]}),e.jsx("p",{className:"ai-description",children:n?"AI will generate unique words based on semantic relationships":"Using curated word lists with quality clues"})]}),e.jsxs("p",{className:"selected-count",children:[i.length," topic",i.length!==1?"s":""," selected"]})]})},D=({grid:t,clues:c,showSolution:i,onCellChange:n})=>{const[s,r]=m.useState({}),a=(u,l,d)=>{const p=`${u}-${l}`,h={...s,[p]:d.toUpperCase()};r(h),n&&n(u,l,d)},g=(u,l)=>{if(i&&!o(u,l))return t[u][l];const d=`${u}-${l}`;return s[d]||""},o=(u,l)=>t[u][l]===".",f=(u,l)=>{if(!c)return null;const d=c.find(p=>p.position.row===u&&p.position.col===l);return d?d.number:null};if(!t||t.length===0)return e.jsx("div",{className:"puzzle-grid",children:"No puzzle loaded"});const x=t.length,j=t[0]?t[0].length:0;return e.jsx("div",{className:"puzzle-container",children:e.jsx("div",{className:"puzzle-grid",style:{gridTemplateColumns:`repeat(${j}, 35px)`,gridTemplateRows:`repeat(${x}, 35px)`},children:t.map((u,l)=>u.map((d,p)=>{const h=f(l,p);return o(l,p)?e.jsx("div",{className:"grid-cell empty-cell",style:{visibility:"hidden"}},`${l}-${p}`):e.jsxs("div",{className:"grid-cell white-cell",children:[h&&e.jsx("span",{className:"cell-number",children:h}),e.jsx("input",{type:"text",maxLength:"1",value:g(l,p),onChange:z=>a(l,p,z.target.value),className:`cell-input ${i?"solution-text":""}`,disabled:i})]},`${l}-${p}`)}))})})},G=({clues:t=[]})=>{const c=t.filter(s=>s.direction==="across"),i=t.filter(s=>s.direction==="down"),n=({title:s,clueList:r})=>e.jsxs("div",{className:"clue-section",children:[e.jsx("h4",{children:s}),e.jsx("ol",{children:r.map(a=>e.jsxs("li",{className:"clue-item",children:[e.jsx("span",{className:"clue-number",children:a.number}),e.jsx("span",{className:"clue-text",children:a.text})]},`${a.number}-${a.direction}`))})]});return e.jsxs("div",{className:"clue-list",children:[e.jsx(n,{title:"Across",clueList:c}),e.jsx(n,{title:"Down",clueList:i})]})},U=({message:t="Generating puzzle..."})=>e.jsxs("div",{className:"loading-spinner",children:[e.jsx("div",{className:"spinner"}),e.jsx("p",{className:"loading-message",children:t})]}),F=()=>{const[t,c]=m.useState(null),[i,n]=m.useState(!1),[s,r]=m.useState(null),[a,g]=m.useState([]),o="",f=m.useCallback(async()=>{try{n(!0);const l=await fetch(`${o}/api/topics`);if(!l.ok)throw new Error("Failed to fetch topics");const d=await l.json();g(d)}catch(l){r(l.message)}finally{n(!1)}},[o]),x=m.useCallback(async(l,d="medium",p=!1)=>{try{n(!0),r(null);const h=await fetch(`${o}/api/generate`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({topics:l,difficulty:d,useAI:p})});if(!h.ok){const z=await h.json().catch(()=>({}));throw new Error(z.message||"Failed to generate puzzle")}const y=await h.json();return c(y),y}catch(h){return r(h.message),null}finally{n(!1)}},[o]),j=m.useCallback(async l=>{try{const d=await fetch(`${o}/api/validate`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({puzzle:t,answers:l})});if(!d.ok)throw new Error("Failed to validate answers");return await d.json()}catch(d){return r(d.message),null}},[o,t]),u=m.useCallback(()=>{c(null),r(null)},[]);return{puzzle:t,loading:i,error:s,topics:a,fetchTopics:f,generatePuzzle:x,validateAnswers:j,resetPuzzle:u}};function B(){const[t,c]=m.useState([]),[i,n]=m.useState("medium"),[s,r]=m.useState(!1),[a,g]=m.useState(!1),{puzzle:o,loading:f,error:x,topics:j,fetchTopics:u,generatePuzzle:l,resetPuzzle:d}=F();m.useEffect(()=>{u()},[u]);const p=async()=>{if(t.length===0){alert("Please select at least one topic");return}await l(t,i,a)},h=N=>{c(N)},y=N=>{g(N)},z=()=>{d(),c([]),r(!1),g(!1),n("medium")},P=()=>{r(!0)};return e.jsxs("div",{className:"crossword-app",children:[e.jsxs("header",{className:"app-header",children:[e.jsx("h1",{className:"app-title",children:"Crossword Puzzle Generator"}),e.jsx("p",{children:"Select topics and generate your custom crossword puzzle!"})]}),e.jsx(L,{onTopicsChange:h,availableTopics:j,selectedTopics:t,useAI:a,onAIToggle:y}),e.jsxs("div",{className:"puzzle-controls",children:[e.jsxs("select",{value:i,onChange:N=>n(N.target.value),className:"control-btn",disabled:!0,title:"Difficulty selection temporarily disabled - using Medium difficulty",children:[e.jsx("option",{value:"easy",children:"Easy"}),e.jsx("option",{value:"medium",children:"Medium"}),e.jsx("option",{value:"hard",children:"Hard"})]}),e.jsx("button",{onClick:p,disabled:f||t.length===0,className:"control-btn generate-btn",children:f?"Generating...":"Generate Puzzle"}),e.jsx("button",{onClick:z,className:"control-btn reset-btn",children:"Reset"}),o&&!s&&e.jsx("button",{onClick:P,className:"control-btn reveal-btn",children:"Reveal Solution"})]}),x&&e.jsxs("div",{className:"error-message",children:["Error: ",x]}),f&&e.jsx(U,{}),o&&!f&&e.jsxs(e.Fragment,{children:[e.jsxs("div",{className:"puzzle-info",children:[e.jsxs("span",{className:"puzzle-stats",children:[o.metadata.wordCount," words • ",o.metadata.size,"×",o.metadata.size," grid"]}),o.metadata.aiGenerated&&e.jsx("span",{className:"ai-generated-badge",children:"🤖 AI-Enhanced"})]}),e.jsxs("div",{className:"puzzle-layout",children:[e.jsx(D,{grid:o.grid,clues:o.clues,showSolution:s}),e.jsx(G,{clues:o.clues})]})]}),!o&&!f&&!x&&e.jsx("div",{style:{textAlign:"center",padding:"40px",color:"#7f8c8d"},children:'Select topics and click "Generate Puzzle" to start!'})]})}v.createRoot(document.getElementById("root")).render(e.jsx(k.StrictMode,{children:e.jsx(B,{})}));
-//# sourceMappingURL=index-Bkj8ir_U.js.map

crossword-app/backend/public/assets/index-Bkj8ir_U.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index-Bkj8ir_U.js","sources":["../../node_modules/react/cjs/react-jsx-runtime.production.min.js","../../node_modules/react/jsx-runtime.js","../../node_modules/react-dom/client.js","../../src/components/TopicSelector.jsx","../../src/components/PuzzleGrid.jsx","../../src/components/ClueList.jsx","../../src/components/LoadingSpinner.jsx","../../src/hooks/useCrossword.js","../../src/App.jsx","../../src/main.jsx"],"sourcesContent":["/**\n * @license React\n * react-jsx-runtime.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n'use strict';var f=require(\"react\"),k=Symbol.for(\"react.element\"),l=Symbol.for(\"react.fragment\"),m=Object.prototype.hasOwnProperty,n=f.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner,p={key:!0,ref:!0,__self:!0,__source:!0};\nfunction q(c,a,g){var b,d={},e=null,h=null;void 0!==g&&(e=\"\"+g);void 0!==a.key&&(e=\"\"+a.key);void 0!==a.ref&&(h=a.ref);for(b in a)m.call(a,b)&&!p.hasOwnProperty(b)&&(d[b]=a[b]);if(c&&c.defaultProps)for(b in a=c.defaultProps,a)void 0===d[b]&&(d[b]=a[b]);return{$$typeof:k,type:c,key:e,ref:h,props:d,_owner:n.current}}exports.Fragment=l;exports.jsx=q;exports.jsxs=q;\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react-jsx-runtime.production.min.js');\n} else {\n  module.exports = require('./cjs/react-jsx-runtime.development.js');\n}\n","'use strict';\n\nvar m = require('react-dom');\nif (process.env.NODE_ENV === 'production') {\n  exports.createRoot = m.createRoot;\n  exports.hydrateRoot = m.hydrateRoot;\n} else {\n  var i = m.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;\n  exports.createRoot = function(c, o) {\n    i.usingClientEntryPoint = true;\n    try {\n      return m.createRoot(c, o);\n    } finally {\n      i.usingClientEntryPoint = false;\n    }\n  };\n  exports.hydrateRoot = function(c, h, o) {\n    i.usingClientEntryPoint = true;\n    try {\n      return m.hydrateRoot(c, h, o);\n    } finally {\n      i.usingClientEntryPoint = false;\n    }\n  };\n}\n","import React from 'react';\n\nconst TopicSelector = ({ \n  onTopicsChange, \n  availableTopics = [], \n  selectedTopics = [],\n  useAI = false,\n  onAIToggle\n}) => {\n  const handleTopicToggle = (topic) => {\n    const newSelectedTopics = selectedTopics.includes(topic)\n      ? selectedTopics.filter(t => t !== topic)\n      : [...selectedTopics, topic];\n    \n    onTopicsChange(newSelectedTopics);\n  };\n\n  return (\n    <div className=\"topic-selector\">\n      <h3>Select Topics</h3>\n      <div className=\"topic-buttons\">\n        {availableTopics.map(topic => (\n          <button\n            key={topic.id}\n            className={`topic-btn ${selectedTopics.includes(topic.name) ? 'selected' : ''}`}\n            onClick={() => handleTopicToggle(topic.name)}\n          >\n            {topic.name}\n          </button>\n        ))}\n      </div>\n      \n      <div className=\"ai-toggle-container\">\n        <label className=\"ai-toggle\">\n          <input\n            type=\"checkbox\"\n            checked={useAI}\n            onChange={(e) => onAIToggle(e.target.checked)}\n            className=\"ai-checkbox\"\n          />\n          <span className=\"ai-label\">\n            🤖 Use AI-powered word generation\n            {useAI && <span className=\"ai-status\"> (Dynamic content)</span>}\n          </span>\n        </label>\n        <p className=\"ai-description\">\n          {useAI \n            ? \"AI will generate unique words based on semantic relationships\" \n            : \"Using curated word lists with quality clues\"\n          }\n        </p>\n      </div>\n      \n      <p className=\"selected-count\">\n        {selectedTopics.length} topic{selectedTopics.length !== 1 ? 's' : ''} selected\n      </p>\n    </div>\n  );\n};\n\nexport default TopicSelector;","import React, { useState } from 'react';\n\nconst PuzzleGrid = ({ grid, clues, showSolution, onCellChange }) => {\n  const [userAnswers, setUserAnswers] = useState({});\n\n  const handleCellInput = (row, col, value) => {\n    const key = `${row}-${col}`;\n    const newAnswers = { ...userAnswers, [key]: value.toUpperCase() };\n    setUserAnswers(newAnswers);\n    onCellChange && onCellChange(row, col, value);\n  };\n\n  const getCellValue = (row, col) => {\n    if (showSolution && !isBlackCell(row, col)) {\n      return grid[row][col];\n    }\n    const key = `${row}-${col}`;\n    return userAnswers[key] || '';\n  };\n\n  const isBlackCell = (row, col) => {\n    return grid[row][col] === '.';\n  };\n\n  const getCellNumber = (row, col) => {\n    if (!clues) return null;\n    const clue = clues.find(c => c.position.row === row && c.position.col === col);\n    return clue ? clue.number : null;\n  };\n\n  if (!grid || grid.length === 0) {\n    return <div className=\"puzzle-grid\">No puzzle loaded</div>;\n  }\n\n  const gridRows = grid.length;\n  const gridCols = grid[0] ? grid[0].length : 0;\n\n  return (\n    <div className=\"puzzle-container\">\n      <div \n        className=\"puzzle-grid\"\n        style={{\n          gridTemplateColumns: `repeat(${gridCols}, 35px)`,\n          gridTemplateRows: `repeat(${gridRows}, 35px)`\n        }}\n      >\n        {grid.map((row, rowIndex) =>\n          row.map((cell, colIndex) => {\n            const cellNumber = getCellNumber(rowIndex, colIndex);\n            const isBlack = isBlackCell(rowIndex, colIndex);\n            \n            // Only render cells that contain letters (not black/unused cells)\n            if (isBlack) {\n              return (\n                <div\n                  key={`${rowIndex}-${colIndex}`}\n                  className=\"grid-cell empty-cell\"\n                  style={{ visibility: 'hidden' }}\n                >\n                </div>\n              );\n            }\n            \n            return (\n              <div\n                key={`${rowIndex}-${colIndex}`}\n                className=\"grid-cell white-cell\"\n              >\n                {cellNumber && <span className=\"cell-number\">{cellNumber}</span>}\n                <input\n                  type=\"text\"\n                  maxLength=\"1\"\n                  value={getCellValue(rowIndex, colIndex)}\n                  onChange={(e) => handleCellInput(rowIndex, colIndex, e.target.value)}\n                  className={`cell-input ${showSolution ? 'solution-text' : ''}`}\n                  disabled={showSolution}\n                />\n              </div>\n            );\n          })\n        )}\n      </div>\n    </div>\n  );\n};\n\nexport default PuzzleGrid;","import React from 'react';\n\nconst ClueList = ({ clues = [] }) => {\n  const acrossClues = clues.filter(clue => clue.direction === 'across');\n  const downClues = clues.filter(clue => clue.direction === 'down');\n\n  const ClueSection = ({ title, clueList }) => (\n    <div className=\"clue-section\">\n      <h4>{title}</h4>\n      <ol>\n        {clueList.map(clue => (\n          <li key={`${clue.number}-${clue.direction}`} className=\"clue-item\">\n            <span className=\"clue-number\">{clue.number}</span>\n            <span className=\"clue-text\">{clue.text}</span>\n          </li>\n        ))}\n      </ol>\n    </div>\n  );\n\n  return (\n    <div className=\"clue-list\">\n      <ClueSection title=\"Across\" clueList={acrossClues} />\n      <ClueSection title=\"Down\" clueList={downClues} />\n    </div>\n  );\n};\n\nexport default ClueList;","import React from 'react';\n\nconst LoadingSpinner = ({ message = \"Generating puzzle...\" }) => {\n  return (\n    <div className=\"loading-spinner\">\n      <div className=\"spinner\"></div>\n      <p className=\"loading-message\">{message}</p>\n    </div>\n  );\n};\n\nexport default LoadingSpinner;","import { useState, useCallback } from 'react';\n\nconst useCrossword = () => {\n  const [puzzle, setPuzzle] = useState(null);\n  const [loading, setLoading] = useState(false);\n  const [error, setError] = useState(null);\n  const [topics, setTopics] = useState([]);\n\n  const API_BASE_URL = import.meta.env.VITE_API_BASE_URL || (import.meta.env.PROD ? '' : 'http://localhost:3000');\n\n  const fetchTopics = useCallback(async () => {\n    try {\n      setLoading(true);\n      const response = await fetch(`${API_BASE_URL}/api/topics`);\n      if (!response.ok) throw new Error('Failed to fetch topics');\n      const data = await response.json();\n      setTopics(data);\n    } catch (err) {\n      setError(err.message);\n    } finally {\n      setLoading(false);\n    }\n  }, [API_BASE_URL]);\n\n  const generatePuzzle = useCallback(async (selectedTopics, difficulty = 'medium', useAI = false) => {\n    try {\n      setLoading(true);\n      setError(null);\n      \n      const response = await fetch(`${API_BASE_URL}/api/generate`, {\n        method: 'POST',\n        headers: {\n          'Content-Type': 'application/json',\n        },\n        body: JSON.stringify({\n          topics: selectedTopics,\n          difficulty,\n          useAI\n        })\n      });\n\n      if (!response.ok) {\n        const errorData = await response.json().catch(() => ({}));\n        throw new Error(errorData.message || 'Failed to generate puzzle');\n      }\n      \n      const puzzleData = await response.json();\n      setPuzzle(puzzleData);\n      return puzzleData;\n    } catch (err) {\n      setError(err.message);\n      return null;\n    } finally {\n      setLoading(false);\n    }\n  }, [API_BASE_URL]);\n\n  const validateAnswers = useCallback(async (userAnswers) => {\n    try {\n      const response = await fetch(`${API_BASE_URL}/api/validate`, {\n        method: 'POST',\n        headers: {\n          'Content-Type': 'application/json',\n        },\n        body: JSON.stringify({\n          puzzle: puzzle,\n          answers: userAnswers\n        })\n      });\n\n      if (!response.ok) throw new Error('Failed to validate answers');\n      \n      return await response.json();\n    } catch (err) {\n      setError(err.message);\n      return null;\n    }\n  }, [API_BASE_URL, puzzle]);\n\n  const resetPuzzle = useCallback(() => {\n    setPuzzle(null);\n    setError(null);\n  }, []);\n\n  return {\n    puzzle,\n    loading,\n    error,\n    topics,\n    fetchTopics,\n    generatePuzzle,\n    validateAnswers,\n    resetPuzzle\n  };\n};\n\nexport default useCrossword;","import React, { useState, useEffect } from 'react';\nimport TopicSelector from './components/TopicSelector';\nimport PuzzleGrid from './components/PuzzleGrid';\nimport ClueList from './components/ClueList';\nimport LoadingSpinner from './components/LoadingSpinner';\nimport useCrossword from './hooks/useCrossword';\nimport './styles/puzzle.css';\n\nfunction App() {\n  const [selectedTopics, setSelectedTopics] = useState([]);\n  const [difficulty, setDifficulty] = useState('medium');\n  const [showSolution, setShowSolution] = useState(false);\n  const [useAI, setUseAI] = useState(false);\n  \n  const {\n    puzzle,\n    loading,\n    error,\n    topics,\n    fetchTopics,\n    generatePuzzle,\n    resetPuzzle\n  } = useCrossword();\n\n  useEffect(() => {\n    fetchTopics();\n  }, [fetchTopics]);\n\n  const handleGeneratePuzzle = async () => {\n    if (selectedTopics.length === 0) {\n      alert('Please select at least one topic');\n      return;\n    }\n    \n    await generatePuzzle(selectedTopics, difficulty, useAI);\n  };\n\n  const handleTopicsChange = (topics) => {\n    setSelectedTopics(topics);\n  };\n\n  const handleAIToggle = (aiEnabled) => {\n    setUseAI(aiEnabled);\n  };\n\n  const handleReset = () => {\n    resetPuzzle();\n    setSelectedTopics([]);\n    setShowSolution(false);\n    setUseAI(false);\n    setDifficulty('medium'); // Always reset to medium\n  };\n\n  const handleRevealSolution = () => {\n    setShowSolution(true);\n  };\n\n  return (\n    <div className=\"crossword-app\">\n      <header className=\"app-header\">\n        <h1 className=\"app-title\">Crossword Puzzle Generator</h1>\n        <p>Select topics and generate your custom crossword puzzle!</p>\n      </header>\n\n      <TopicSelector \n        onTopicsChange={handleTopicsChange}\n        availableTopics={topics}\n        selectedTopics={selectedTopics}\n        useAI={useAI}\n        onAIToggle={handleAIToggle}\n      />\n\n      <div className=\"puzzle-controls\">\n        <select \n          value={difficulty} \n          onChange={(e) => setDifficulty(e.target.value)}\n          className=\"control-btn\"\n          disabled\n          title=\"Difficulty selection temporarily disabled - using Medium difficulty\"\n        >\n          <option value=\"easy\">Easy</option>\n          <option value=\"medium\">Medium</option>\n          <option value=\"hard\">Hard</option>\n        </select>\n        \n        <button\n          onClick={handleGeneratePuzzle}\n          disabled={loading || selectedTopics.length === 0}\n          className=\"control-btn generate-btn\"\n        >\n          {loading ? 'Generating...' : 'Generate Puzzle'}\n        </button>\n        \n        <button\n          onClick={handleReset}\n          className=\"control-btn reset-btn\"\n        >\n          Reset\n        </button>\n        \n        {puzzle && !showSolution && (\n          <button\n            onClick={handleRevealSolution}\n            className=\"control-btn reveal-btn\"\n          >\n            Reveal Solution\n          </button>\n        )}\n      </div>\n\n      {error && (\n        <div className=\"error-message\">\n          Error: {error}\n        </div>\n      )}\n\n      {loading && <LoadingSpinner />}\n\n      {puzzle && !loading && (\n        <>\n          <div className=\"puzzle-info\">\n            <span className=\"puzzle-stats\">\n              {puzzle.metadata.wordCount} words • {puzzle.metadata.size}×{puzzle.metadata.size} grid\n            </span>\n            {puzzle.metadata.aiGenerated && (\n              <span className=\"ai-generated-badge\">🤖 AI-Enhanced</span>\n            )}\n          </div>\n          <div className=\"puzzle-layout\">\n            <PuzzleGrid \n              grid={puzzle.grid} \n              clues={puzzle.clues}\n              showSolution={showSolution}\n            />\n            <ClueList clues={puzzle.clues} />\n          </div>\n        </>\n      )}\n\n      {!puzzle && !loading && !error && (\n        <div style={{ textAlign: 'center', padding: '40px', color: '#7f8c8d' }}>\n          Select topics and click \"Generate Puzzle\" to start!\n        </div>\n      )}\n    </div>\n  );\n}\n\nexport default App;","import React from 'react'\nimport ReactDOM from 'react-dom/client'\nimport App from './App.jsx'\n\nReactDOM.createRoot(document.getElementById('root')).render(\n  <React.StrictMode>\n    <App />\n  </React.StrictMode>,\n)"],"names":["f","require$$0","k","l","m","n","p","q","c","a","g","b","d","e","h","reactJsxRuntime_production_min","jsxRuntimeModule","client","TopicSelector","onTopicsChange","availableTopics","selectedTopics","useAI","onAIToggle","handleTopicToggle","topic","newSelectedTopics","t","jsxs","jsx","PuzzleGrid","grid","clues","showSolution","onCellChange","userAnswers","setUserAnswers","useState","handleCellInput","row","col","value","key","newAnswers","getCellValue","isBlackCell","getCellNumber","clue","gridRows","gridCols","rowIndex","cell","colIndex","cellNumber","ClueList","acrossClues","downClues","ClueSection","title","clueList","LoadingSpinner","message","useCrossword","puzzle","setPuzzle","loading","setLoading","error","setError","topics","setTopics","API_BASE_URL","fetchTopics","useCallback","response","data","err","generatePuzzle","difficulty","errorData","puzzleData","validateAnswers","resetPuzzle","App","setSelectedTopics","setDifficulty","setShowSolution","setUseAI","useEffect","handleGeneratePuzzle","handleTopicsChange","handleAIToggle","aiEnabled","handleReset","handleRevealSolution","Fragment","ReactDOM","React"],"mappings":"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","x_google_ignoreList":[0,1,2]}

crossword-app/backend/public/assets/index-V4v18wFW.css

@@ -1 +0,0 @@
-.crossword-app{max-width:1200px;margin:0 auto;padding:20px;font-family:Segoe UI,Tahoma,Geneva,Verdana,sans-serif}.app-header{text-align:center;margin-bottom:30px}.app-title{color:#2c3e50;font-size:2.5rem;margin-bottom:10px}.topic-selector{background:#f8f9fa;padding:20px;border-radius:8px;margin-bottom:20px}.topic-selector h3{margin-top:0;color:#2c3e50}.topic-buttons{display:flex;flex-wrap:wrap;gap:10px;margin-bottom:15px}.topic-btn{padding:8px 16px;border:2px solid #3498db;background:#fff;color:#3498db;border-radius:20px;cursor:pointer;transition:all .3s ease;font-weight:500}.topic-btn:hover,.topic-btn.selected{background:#3498db;color:#fff}.selected-count{color:#7f8c8d;font-size:.9rem;margin:0}.ai-toggle-container{margin:20px 0;padding:15px;background:#f8f9fa;border-radius:8px;border:2px solid #e9ecef;transition:all .3s ease}.ai-toggle-container:has(.ai-checkbox:checked){background:linear-gradient(135deg,#e3f2fd,#f3e5f5);border-color:#3498db}.ai-toggle{display:flex;align-items:center;cursor:pointer;font-weight:500;margin-bottom:8px}.ai-checkbox{width:20px;height:20px;margin-right:12px;cursor:pointer;accent-color:#3498db}.ai-label{font-size:1rem;color:#2c3e50;-webkit-user-select:none;user-select:none}.ai-status{color:#27ae60;font-weight:600;font-size:.9rem}.ai-description{margin:0;font-size:.85rem;color:#6c757d;line-height:1.4;padding-left:32px}.puzzle-controls{display:flex;gap:15px;margin-bottom:20px;justify-content:center}.control-btn{padding:10px 20px;border:none;border-radius:5px;cursor:pointer;font-weight:600;transition:background-color .3s ease}.control-btn:disabled{background:#bdc3c7!important;color:#7f8c8d!important;cursor:not-allowed;opacity:.7}.generate-btn{background:#27ae60;color:#fff}.generate-btn:hover{background:#229954}.generate-btn:disabled{background:#bdc3c7;cursor:not-allowed}.reset-btn{background:#e74c3c;color:#fff}.reset-btn:hover{background:#c0392b}.reveal-btn{background:#f39c12;color:#fff}.reveal-btn:hover{background:#e67e22}.loading-spinner{display:flex;flex-direction:column;align-items:center;padding:40px}.spinner{width:40px;height:40px;border:4px solid #f3f3f3;border-top:4px solid #3498db;border-radius:50%;animation:spin 1s linear infinite;margin-bottom:15px}@keyframes spin{0%{transform:rotate(0)}to{transform:rotate(360deg)}}.loading-message{color:#7f8c8d;font-size:1.1rem}.puzzle-info{display:flex;justify-content:space-between;align-items:center;margin:20px 0 10px;padding:10px 15px;background:#f8f9fa;border-radius:6px;border-left:4px solid #3498db}.puzzle-stats{font-size:.9rem;color:#6c757d;font-weight:500}.ai-generated-badge{background:linear-gradient(135deg,#667eea,#764ba2);color:#fff;padding:4px 12px;border-radius:15px;font-size:.8rem;font-weight:600;text-shadow:0 1px 2px rgba(0,0,0,.2);box-shadow:0 2px 4px #0000001a}.puzzle-layout{display:grid;grid-template-columns:1fr 300px;gap:30px;margin-top:20px}@media (max-width: 768px){.puzzle-layout{grid-template-columns:1fr;gap:20px}.puzzle-info{flex-direction:column;gap:8px;text-align:center}.ai-toggle-container{padding:12px}.ai-description{padding-left:0;text-align:center}}.puzzle-container{display:flex;justify-content:center}.puzzle-grid{display:grid;gap:0;margin:0 auto;width:fit-content;height:fit-content}.grid-cell{width:35px;height:35px;position:relative;display:flex;align-items:center;justify-content:center;box-sizing:border-box;background:#fff}.grid-cell:before{content:"";position:absolute;top:0;left:0;right:-1px;bottom:-1px;border:1px solid #2c3e50;pointer-events:none;z-index:10}.black-cell{background:#f0f0f0}.black-cell:before{background:#f0f0f0;border:1px solid #2c3e50}.white-cell{background:#fff}.empty-cell{background:transparent;border:none;visibility:hidden}.empty-cell:before{display:none}.cell-input{width:100%;height:100%;border:none!important;text-align:center;font-size:16px;font-weight:700;background:transparent;outline:none;text-transform:uppercase;position:relative;z-index:5}.cell-input:focus{background:#e8f4fd;box-shadow:inset 0 0 0 2px #3498db}.cell-number{position:absolute;top:1px;left:2px;font-size:10px;font-weight:700;color:#2c3e50;line-height:1;z-index:15;pointer-events:none}.solution-text{color:#2c3e50!important;font-weight:700!important;background:#fff!important}.solution-text:disabled{opacity:1!important;cursor:default}.grid-cell .solution-text{border:none!important;background:#fff!important}.clue-list{background:#f8f9fa;padding:20px;border-radius:8px;max-height:600px;overflow-y:auto}.clue-section{margin-bottom:25px}.clue-section h4{color:#2c3e50;margin-bottom:15px;font-size:1.2rem;border-bottom:2px solid #3498db;padding-bottom:5px}.clue-section ol{padding-left:0;list-style:none}.clue-item{display:flex;margin-bottom:8px;padding:8px;border-radius:4px;cursor:pointer;transition:background-color .2s ease}.clue-item:hover{background:#e9ecef}.clue-number{font-weight:700;color:#3498db;margin-right:10px;min-width:25px}.clue-text{flex:1;color:#2c3e50}.error-message{background:#f8d7da;color:#721c24;padding:15px;border-radius:5px;margin:20px 0;border:1px solid #f5c6cb}.success-message{background:#d4edda;color:#155724;padding:15px;border-radius:5px;margin:20px 0;border:1px solid #c3e6cb;text-align:center;font-weight:600}

crossword-app/backend/public/index.html

@@ -1,16 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <meta name="description" content="Generate custom crossword puzzles by selecting topics" />
-    <meta name="keywords" content="crossword, puzzle, word game, brain teaser" />
-    <title>Crossword Puzzle Generator</title>
-    <script type="module" crossorigin src="/assets/index-Bkj8ir_U.js"></script>
-    <link rel="modulepreload" crossorigin href="/assets/vendor-nf7bT_Uh.js">
-    <link rel="stylesheet" crossorigin href="/assets/index-V4v18wFW.css">
-  </head>
-  <body>
-    <div id="root"></div>
-  </body>
-</html>

crossword-app/backend/setup-env.sh

@@ -1,33 +0,0 @@
-#!/bin/bash
-
-# Crossword App - Environment Setup Script
-echo "🛠️  Setting up Crossword App environment..."
-
-# Check if .env already exists
-if [ -f ".env" ]; then
-    echo "⚠️  .env file already exists!"
-    echo "   Backup created as .env.backup"
-    cp .env .env.backup
-fi
-
-# Copy template
-echo "📋 Copying .env.example to .env..."
-cp .env.example .env
-
-echo "✅ Environment file created!"
-echo ""
-echo "🔑 Next steps:"
-echo "   1. Edit .env file with your settings:"
-echo "      nano .env"
-echo ""
-echo "   2. Add your HuggingFace API key:"
-echo "      HUGGINGFACE_API_KEY=hf_your_real_key_here"
-echo ""
-echo "   3. Optionally enable AI by default:"
-echo "      USE_AI_WORDS=true"
-echo ""
-echo "   4. Start the development server:"
-echo "      npm run dev"
-echo ""
-echo "📚 Get HuggingFace API key: https://huggingface.co/settings/tokens"
-echo "🔒 Your .env file is gitignored and secure!"

crossword-app/backend/src/app.js

@@ -1,175 +0,0 @@
-require('dotenv').config();
-
-// Suppress HuggingFace verbose logging
-process.env.HF_HUB_VERBOSITY = 'error';
-process.env.TRANSFORMERS_VERBOSITY = 'error';
-
-const express = require('express');
-const cors = require('cors');
-const helmet = require('helmet');
-const rateLimit = require('express-rate-limit');
-const path = require('path');
-const apiRoutes = require('./routes/api');
-
-const app = express();
-const PORT = process.env.PORT || 7860;
-
-// Trust proxy for platforms like Hugging Face Spaces, Heroku, etc.
-if (process.env.NODE_ENV === 'production') {
-  app.set('trust proxy', 1);
-}
-
-app.use(helmet());
-
-// CORS configuration
-let corsOptions;
-if (process.env.NODE_ENV === 'production') {
-  // In production, allow same origin (since frontend is served from same server)
-  corsOptions = {
-    origin: true,
-    credentials: true,
-    optionsSuccessStatus: 200
-  };
-} else {
-  // Development mode - allow dev servers
-  corsOptions = {
-    origin: process.env.CORS_ORIGIN || ['http://localhost:5173', 'http://localhost:3000'],
-    credentials: true,
-    optionsSuccessStatus: 200
-  };
-}
-app.use(cors(corsOptions));
-
-const limiter = rateLimit({
-  windowMs: 15 * 60 * 1000,
-  max: 100,
-  message: 'Too many requests from this IP, please try again later.',
-  standardHeaders: true,
-  legacyHeaders: false,
-});
-app.use(limiter);
-
-const generateLimiter = rateLimit({
-  windowMs: 5 * 60 * 1000,
-  max: 50,
-  message: 'Too many puzzle generation requests, please wait before trying again.',
-});
-
-app.use(express.json({ limit: '10mb' }));
-app.use(express.urlencoded({ extended: true, limit: '10mb' }));
-
-// Basic request logging without detailed headers
-app.use((req, res, next) => {
-  console.log(`${new Date().toISOString()} - ${req.method} ${req.path}`);
-  next();
-});
-
-app.use('/api/generate', generateLimiter);
-app.use('/api', apiRoutes);
-
-// Serve static files in production
-if (process.env.NODE_ENV === 'production') {
-  const staticPath = path.join(__dirname, '../public');
-  console.log(`Static files path: ${staticPath}`);
-  
-  // Check if static files exist
-  const fs = require('fs');
-  try {
-    const files = fs.readdirSync(staticPath);
-    console.log(`Static files found:`, files);
-    
-    // Check assets directory specifically
-    const assetsPath = path.join(staticPath, 'assets');
-    if (fs.existsSync(assetsPath)) {
-      const assetFiles = fs.readdirSync(assetsPath);
-      console.log(`Assets directory contents:`, assetFiles);
-    } else {
-      console.error(`Assets directory not found at: ${assetsPath}`);
-    }
-  } catch (error) {
-    console.error(`Error reading static files directory:`, error.message);
-  }
-  
-  app.use(express.static(staticPath));
-  
-  // Test route to check if static serving works
-  app.get('/test-static', (req, res) => {
-    const fs = require('fs');
-    const assetsPath = path.join(staticPath, 'assets');
-    try {
-      const files = fs.readdirSync(assetsPath);
-      res.json({ staticPath, assetsPath, files });
-    } catch (error) {
-      res.status(500).json({ error: error.message, staticPath, assetsPath });
-    }
-  });
-  
-  
-  // Handle React Router routes - serve index.html for non-API routes
-  app.get('*', (req, res) => {
-    // Ensure we're sending the right content type
-    res.setHeader('Content-Type', 'text/html; charset=utf-8');
-    res.sendFile(path.join(staticPath, 'index.html'));
-  });
-} else {
-  // Development mode - show API info
-  app.get('/', (req, res) => {
-    res.json({
-      message: 'Crossword Puzzle API',
-      version: '1.0.0',
-      mode: 'development',
-      endpoints: {
-        topics: 'GET /api/topics',
-        generate: 'POST /api/generate',
-        validate: 'POST /api/validate',
-        words: 'GET /api/words/:topic',
-        health: 'GET /api/health'
-      }
-    });
-  });
-}
-
-app.use((req, res) => {
-  res.status(404).json({
-    error: 'Not Found',
-    message: `Route ${req.method} ${req.path} not found`,
-    timestamp: new Date().toISOString()
-  });
-});
-
-app.use((error, req, res, next) => {
-  console.error('Error:', error);
-  
-  if (error.type === 'entity.parse.failed') {
-    return res.status(400).json({
-      error: 'Invalid JSON',
-      message: 'Request body contains invalid JSON'
-    });
-  }
-  
-  res.status(500).json({
-    error: 'Internal Server Error',
-    message: process.env.NODE_ENV === 'production' 
-      ? 'Something went wrong' 
-      : error.message,
-    timestamp: new Date().toISOString()
-  });
-});
-
-if (require.main === module) {
-  const HOST = process.env.NODE_ENV === 'production' ? '0.0.0.0' : 'localhost';
-  app.listen(PORT, HOST, () => {
-    console.log(`Server running on ${HOST}:${PORT}`);
-    console.log(`Environment: ${process.env.NODE_ENV || 'development'}`);
-    console.log(`Working directory: ${process.cwd()}`);
-    console.log(`App file location: ${__dirname}`);
-    if (process.env.NODE_ENV === 'production') {
-      console.log(`Serving React app from /public directory`);
-      console.log(`CORS enabled for same origin`);
-    } else {
-      console.log(`CORS enabled for: ${JSON.stringify(corsOptions.origin)}`);
-    }
-  });
-}
-
-module.exports = app;

crossword-app/backend/src/controllers/puzzleController.js

@@ -1,65 +0,0 @@
-const CrosswordGenerator = require('../services/crosswordGenerator');
-const WordService = require('../services/wordService');
-
-class PuzzleController {
-  static async getTopics(req, res) {
-    try {
-      const topics = await WordService.getAllTopics();
-      res.json(topics);
-    } catch (error) {
-      console.error('Error fetching topics:', error);
-      res.status(500).json({ error: 'Failed to fetch topics' });
-    }
-  }
-
-  static async generatePuzzle(req, res) {
-    try {
-      const { topics, difficulty = 'medium', useAI = false } = req.body;
-      
-      if (!topics || !Array.isArray(topics) || topics.length === 0) {
-        return res.status(400).json({ error: 'Topics array is required' });
-      }
-
-      const generator = new CrosswordGenerator();
-      const puzzle = await generator.generatePuzzle(topics, difficulty, { useAI });
-      
-      if (!puzzle) {
-        return res.status(400).json({ error: 'Could not generate puzzle with selected topics' });
-      }
-
-      res.json(puzzle);
-    } catch (error) {
-      console.error('Error generating puzzle:', error);
-      res.status(500).json({ error: 'Failed to generate puzzle' });
-    }
-  }
-
-  static async validateAnswers(req, res) {
-    try {
-      const { puzzle, answers } = req.body;
-      
-      if (!puzzle || !answers) {
-        return res.status(400).json({ error: 'Puzzle and answers are required' });
-      }
-
-      const validation = CrosswordGenerator.validateAnswers(puzzle, answers);
-      res.json(validation);
-    } catch (error) {
-      console.error('Error validating answers:', error);
-      res.status(500).json({ error: 'Failed to validate answers' });
-    }
-  }
-
-  static async getWords(req, res) {
-    try {
-      const { topic } = req.params;
-      const words = await WordService.getWordsByTopic(topic);
-      res.json(words);
-    } catch (error) {
-      console.error('Error fetching words:', error);
-      res.status(500).json({ error: 'Failed to fetch words' });
-    }
-  }
-}
-
-module.exports = PuzzleController;

crossword-app/backend/src/models/Topic.js

@@ -1,144 +0,0 @@
-class Topic {
-  constructor({ id, name, description, wordCount = 0, difficulty = 'medium' }) {
-    this.id = id;
-    this.name = name;
-    this.description = description;
-    this.wordCount = wordCount;
-    this.difficulty = difficulty;
-    this.createdAt = new Date();
-    this.updatedAt = new Date();
-  }
-
-  static validateTopic(topicData) {
-    const errors = [];
-    
-    if (!topicData.name || typeof topicData.name !== 'string') {
-      errors.push('Topic name is required and must be a string');
-    } else if (topicData.name.length < 2 || topicData.name.length > 50) {
-      errors.push('Topic name must be between 2 and 50 characters');
-    }
-    
-    if (topicData.description && typeof topicData.description !== 'string') {
-      errors.push('Description must be a string');
-    }
-    
-    if (topicData.difficulty && !['easy', 'medium', 'hard'].includes(topicData.difficulty)) {
-      errors.push('Difficulty must be easy, medium, or hard');
-    }
-    
-    return {
-      isValid: errors.length === 0,
-      errors
-    };
-  }
-
-  static fromJSON(data) {
-    return new Topic(data);
-  }
-
-  toJSON() {
-    return {
-      id: this.id,
-      name: this.name,
-      description: this.description,
-      wordCount: this.wordCount,
-      difficulty: this.difficulty,
-      createdAt: this.createdAt,
-      updatedAt: this.updatedAt
-    };
-  }
-
-  updateWordCount(count) {
-    this.wordCount = count;
-    this.updatedAt = new Date();
-  }
-
-  getDisplayName() {
-    return this.name
-      .split(/[-_\s]+/)
-      .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
-      .join(' ');
-  }
-
-  getSlug() {
-    return this.name
-      .toLowerCase()
-      .replace(/[^a-z0-9]+/g, '-')
-      .replace(/^-+|-+$/g, '');
-  }
-
-  isPopular() {
-    return this.wordCount >= 20;
-  }
-
-  getDifficultyLevel() {
-    const levels = {
-      easy: 1,
-      medium: 2,
-      hard: 3
-    };
-    
-    return levels[this.difficulty] || 2;
-  }
-
-  static getDefaultTopics() {
-    return [
-      new Topic({
-        id: 'animals',
-        name: 'Animals',
-        description: 'Various animals from around the world',
-        wordCount: 25,
-        difficulty: 'easy'
-      }),
-      new Topic({
-        id: 'science',
-        name: 'Science',
-        description: 'Scientific terms and concepts',
-        wordCount: 30,
-        difficulty: 'medium'
-      }),
-      new Topic({
-        id: 'geography',
-        name: 'Geography',
-        description: 'Countries, cities, and geographical features',
-        wordCount: 28,
-        difficulty: 'medium'
-      }),
-      new Topic({
-        id: 'technology',
-        name: 'Technology',
-        description: 'Computer and technology terms',
-        wordCount: 35,
-        difficulty: 'hard'
-      }),
-      new Topic({
-        id: 'history',
-        name: 'History',
-        description: 'Historical events and figures',
-        wordCount: 22,
-        difficulty: 'hard'
-      }),
-      new Topic({
-        id: 'sports',
-        name: 'Sports',
-        description: 'Sports and athletic activities',
-        wordCount: 20,
-        difficulty: 'easy'
-      })
-    ];
-  }
-
-  static sortByDifficulty(topics) {
-    return topics.sort((a, b) => a.getDifficultyLevel() - b.getDifficultyLevel());
-  }
-
-  static sortByPopularity(topics) {
-    return topics.sort((a, b) => b.wordCount - a.wordCount);
-  }
-
-  static filterByDifficulty(topics, difficulty) {
-    return topics.filter(topic => topic.difficulty === difficulty);
-  }
-}
-
-module.exports = Topic;

crossword-app/backend/src/models/Word.js

@@ -1,112 +0,0 @@
-class Word {
-  constructor({ id, word, clue, topic, difficulty = 'medium', length }) {
-    this.id = id;
-    this.word = word.toUpperCase();
-    this.clue = clue;
-    this.topic = topic;
-    this.difficulty = difficulty;
-    this.length = length || word.length;
-    this.createdAt = new Date();
-  }
-
-  static validateWord(wordData) {
-    const errors = [];
-    
-    if (!wordData.word || typeof wordData.word !== 'string') {
-      errors.push('Word is required and must be a string');
-    } else if (wordData.word.length < 2 || wordData.word.length > 15) {
-      errors.push('Word must be between 2 and 15 characters');
-    } else if (!/^[A-Za-z]+$/.test(wordData.word)) {
-      errors.push('Word must contain only letters');
-    }
-    
-    if (!wordData.clue || typeof wordData.clue !== 'string') {
-      errors.push('Clue is required and must be a string');
-    }
-    
-    if (!wordData.topic || typeof wordData.topic !== 'string') {
-      errors.push('Topic is required and must be a string');
-    }
-    
-    if (wordData.difficulty && !['easy', 'medium', 'hard'].includes(wordData.difficulty)) {
-      errors.push('Difficulty must be easy, medium, or hard');
-    }
-    
-    return {
-      isValid: errors.length === 0,
-      errors
-    };
-  }
-
-  static fromJSON(data) {
-    return new Word(data);
-  }
-
-  toJSON() {
-    return {
-      id: this.id,
-      word: this.word,
-      clue: this.clue,
-      topic: this.topic,
-      difficulty: this.difficulty,
-      length: this.length,
-      createdAt: this.createdAt
-    };
-  }
-
-  getDifficultyScore() {
-    const baseScore = this.length;
-    const difficultyMultiplier = {
-      easy: 1,
-      medium: 1.2,
-      hard: 1.5
-    };
-    
-    return Math.round(baseScore * (difficultyMultiplier[this.difficulty] || 1));
-  }
-
-  isCompatibleWith(otherWord) {
-    if (!otherWord || !(otherWord instanceof Word)) {
-      return false;
-    }
-    
-    const thisWord = this.word;
-    const otherWordStr = otherWord.word;
-    
-    for (let i = 0; i < thisWord.length; i++) {
-      for (let j = 0; j < otherWordStr.length; j++) {
-        if (thisWord[i] === otherWordStr[j]) {
-          return true;
-        }
-      }
-    }
-    
-    return false;
-  }
-
-  getIntersectionPoints(otherWord) {
-    if (!this.isCompatibleWith(otherWord)) {
-      return [];
-    }
-    
-    const intersections = [];
-    const thisWord = this.word;
-    const otherWordStr = otherWord.word;
-    
-    for (let i = 0; i < thisWord.length; i++) {
-      for (let j = 0; j < otherWordStr.length; j++) {
-        if (thisWord[i] === otherWordStr[j]) {
-          intersections.push({
-            thisIndex: i,
-            otherIndex: j,
-            letter: thisWord[i]
-          });
-        }
-      }
-    }
-    
-    return intersections;
-  }
-}
-
-module.exports = Word;

crossword-app/backend/src/routes/api.js

@@ -1,82 +0,0 @@
-const express = require('express');
-const PuzzleController = require('../controllers/puzzleController');
-const EmbeddingWordService = require('../services/embeddingWordService');
-
-const router = express.Router();
-
-router.get('/topics', PuzzleController.getTopics);
-
-router.post('/generate', PuzzleController.generatePuzzle);
-
-router.post('/validate', PuzzleController.validateAnswers);
-
-router.get('/words/:topic', PuzzleController.getWords);
-
-router.get('/health', (req, res) => {
-  res.json({ 
-    status: 'OK', 
-    timestamp: new Date().toISOString(),
-    service: 'Crossword API'
-  });
-});
-
-// AI/Embedding service endpoints
-router.get('/ai/status', async (req, res) => {
-  try {
-    const stats = EmbeddingWordService.getCacheStats();
-    res.json({
-      status: 'OK',
-      aiService: {
-        initialized: stats.isInitialized,
-        fallbackEnabled: stats.fallbackEnabled,
-        cacheStats: {
-          embeddingCache: stats.embeddingCacheSize,
-          wordCache: stats.wordCacheSize
-        }
-      },
-      timestamp: new Date().toISOString()
-    });
-  } catch (error) {
-    res.status(500).json({
-      status: 'ERROR',
-      error: error.message,
-      timestamp: new Date().toISOString()
-    });
-  }
-});
-
-router.post('/ai/generate-words', async (req, res) => {
-  try {
-    const { topics, difficulty = 'medium', count = 12 } = req.body;
-    
-    if (!topics || !Array.isArray(topics) || topics.length === 0) {
-      return res.status(400).json({
-        error: 'Topics array is required',
-        example: { topics: ['animals', 'science'], difficulty: 'medium', count: 12 }
-      });
-    }
-
-    const words = await EmbeddingWordService.generateWordsForTopics(topics, difficulty, count);
-    
-    res.json({
-      success: true,
-      topics,
-      difficulty,
-      requestedCount: count,
-      generatedCount: words.length,
-      words: words,
-      timestamp: new Date().toISOString(),
-      aiGenerated: EmbeddingWordService.getCacheStats().isInitialized
-    });
-    
-  } catch (error) {
-    console.error('Error generating AI words:', error);
-    res.status(500).json({
-      error: 'Failed to generate words',
-      message: error.message,
-      timestamp: new Date().toISOString()
-    });
-  }
-});
-
-module.exports = router;

crossword-app/backend/src/services/crosswordGenerator.js

@@ -1,982 +0,0 @@
-const WordService = require('./wordService');
-const EmbeddingWordService = require('./embeddingWordService');
-
-class CrosswordGenerator {
-  constructor() {
-    this.maxAttempts = 100;
-    this.minWords = 6;
-    this.maxWords = 12;
-    this.useAI = process.env.USE_AI_WORDS === 'true';
-  }
-
-  async generatePuzzle(topics, difficulty = 'medium', options = {}) {
-    try {
-      const useAI = options.useAI !== undefined ? options.useAI : this.useAI;
-      
-      const words = await this.selectWords(topics, difficulty, useAI);
-      
-      // Log word->clue mapping for debugging
-      this.logWordClueMapping(words, useAI, topics);
-      
-      if (words.length < this.minWords) {
-        console.error(`❌ Not enough words: ${words.length} < ${this.minWords}`);
-        throw new Error('Not enough words available for selected topics');
-      }
-
-      const gridResult = this.createGrid(words);
-      
-      if (!gridResult) {
-        console.error(`❌ Grid creation failed - could not place words`);
-        throw new Error('Could not place words in grid');
-      }
-      
-      const clues = this.generateClues(words, gridResult.placedWords);
-      
-      return {
-        grid: gridResult.grid,
-        clues: clues,
-        metadata: {
-          topics,
-          difficulty,
-          wordCount: words.length,
-          size: gridResult.size,
-          aiGenerated: useAI && EmbeddingWordService.getCacheStats().isInitialized
-        }
-      };
-    } catch (error) {
-      console.error('❌ Error generating puzzle:', error);
-      return null;
-    }
-  }
-
-  async selectWords(topics, difficulty, useAI = false) {
-    try {
-      if (useAI) {
-        console.log(`🤖 Using AI-powered word generation for topics: ${topics.join(', ')}`);
-        const aiWords = await EmbeddingWordService.generateWordsForTopics(topics, difficulty, this.maxWords);
-        
-        if (aiWords.length >= this.minWords) {
-          console.log(`✅ AI generated ${aiWords.length} words successfully`);
-          return aiWords;
-        } else {
-          console.log(`⚠️  AI only generated ${aiWords.length} words, falling back to static`);
-        }
-      }
-
-      // Fallback to static word selection
-      console.log(`📚 Using static word selection for topics: ${topics.join(', ')}`);
-      const allWords = [];
-      
-      for (const topic of topics) {
-        const topicWords = await WordService.getWordsByTopic(topic);
-        allWords.push(...topicWords);
-      }
-
-      const filteredWords = this.filterWordsByDifficulty(allWords, difficulty);
-      
-      // Sort words to prioritize those with good intersection potential
-      const sortedWords = this.sortWordsForCrossword(filteredWords);
-      
-      return sortedWords.slice(0, this.maxWords);
-      
-    } catch (error) {
-      console.error('❌ Error in word selection:', error.message);
-      // Final fallback to basic static selection
-      return await this.getBasicStaticWords(topics, difficulty);
-    }
-  }
-
-  async getBasicStaticWords(topics, difficulty) {
-    try {
-      const allWords = [];
-      for (const topic of topics) {
-        const topicWords = await WordService.getWordsByTopic(topic);
-        allWords.push(...topicWords.slice(0, 20)); // Limit per topic
-      }
-      const filtered = this.filterWordsByDifficulty(allWords, difficulty);
-      return filtered.slice(0, this.maxWords);
-    } catch (error) {
-      console.error('❌ Even basic word selection failed:', error);
-      return [];
-    }
-  }
-
-  sortWordsForCrossword(words) {
-    // Score words based on their crossword potential
-    const scoredWords = words.map(wordObj => {
-      const word = wordObj.word;
-      let score = 0;
-      
-      // Moderate preference for medium-length words (5-7 chars optimal)
-      if (word.length >= 5 && word.length <= 7) {
-        score += 10; // Good base score for medium words
-      } else if (word.length >= 3 && word.length <= 4) {
-        score += 5; // Short words get some points
-      } else if (word.length >= 8) {
-        score += 3; // Long words get fewer points
-      }
-      
-      // Words with common letters get bonus points
-      const commonLetters = ['E', 'A', 'R', 'I', 'O', 'T', 'N', 'S'];
-      for (const letter of word) {
-        if (commonLetters.includes(letter)) {
-          score += 1;
-        }
-      }
-      
-      // Vowel distribution bonus
-      const vowels = ['A', 'E', 'I', 'O', 'U'];
-      const vowelCount = word.split('').filter(letter => vowels.includes(letter)).length;
-      score += vowelCount;
-      
-      return { ...wordObj, crosswordScore: score };
-    });
-    
-    // Sort by score (descending) then shuffle within score groups
-    scoredWords.sort((a, b) => {
-      if (Math.abs(a.crosswordScore - b.crosswordScore) <= 3) {
-        return Math.random() - 0.5; // Shuffle similar scores
-      }
-      return b.crosswordScore - a.crosswordScore;
-    });
-    
-    return scoredWords;
-  }
-
-  filterWordsByDifficulty(words, difficulty) {
-    const difficultyMap = {
-      easy: { minLen: 3, maxLen: 8 },
-      medium: { minLen: 4, maxLen: 10 },
-      hard: { minLen: 5, maxLen: 15 }
-    };
-    
-    const { minLen, maxLen } = difficultyMap[difficulty] || difficultyMap.medium;
-    
-    return words.filter(word => 
-      word.word.length >= minLen && word.word.length <= maxLen
-    );
-  }
-
-  createGrid(words) {
-    if (!words || words.length === 0) {
-      console.error(`❌ No words provided to createGrid`);
-      return null;
-    }
-
-    const wordList = words.map(w => w.word.toUpperCase()).sort((a, b) => b.length - a.length);
-    const size = this.calculateGridSize(wordList);
-    
-    // Try with different grid sizes and word counts
-    for (let attempt = 0; attempt < 3; attempt++) {
-      const currentSize = size + attempt;
-      
-      // First try with all words
-      let result = this.placeWordsInGrid(wordList, currentSize);
-      if (result) {
-        return { grid: result.grid, size: currentSize, placedWords: result.placedWords };
-      }
-      
-      // If that fails, try with 1-2 fewer words (but not too aggressive)
-      if (wordList.length > 7) {
-        const reducedWords = wordList.slice(0, wordList.length - 1);
-        result = this.placeWordsInGrid(reducedWords, currentSize);
-        if (result) {
-          return { grid: result.grid, size: currentSize, placedWords: result.placedWords };
-        }
-      }
-    }
-    
-    // Only as last resort, try with minimum words
-    for (let attempt = 0; attempt < 2; attempt++) {
-      const currentSize = size + attempt;
-      if (wordList.length >= 6) {
-        const minWords = wordList.slice(0, 6);
-        const result = this.placeWordsInGrid(minWords, currentSize);
-        if (result) {
-          return { grid: result.grid, size: currentSize, placedWords: result.placedWords };
-        }
-      }
-    }
-    
-    // Absolute last resort: simple cross pattern with just 2 words
-    if (wordList.length >= 2) {
-      const result = this.createSimpleCross(wordList.slice(0, 2));
-      if (result) {
-        return result;
-      }
-    }
-    
-    console.error(`❌ All grid creation attempts failed`);
-    return null;
-  }
-
-  calculateGridSize(words) {
-    const totalChars = words.reduce((sum, word) => sum + word.length, 0);
-    const longestWord = Math.max(...words.map(word => word.length));
-    return Math.max(
-      Math.ceil(Math.sqrt(totalChars * 1.5)),
-      longestWord,
-      8
-    );
-  }
-
-  trimGrid(grid, placedWords) {
-    if (!placedWords || placedWords.length === 0) return grid;
-    
-    // Find the bounds of the actual puzzle
-    let minRow = grid.length, maxRow = -1;
-    let minCol = grid[0].length, maxCol = -1;
-    
-    placedWords.forEach(word => {
-      const { row, col, direction } = word;
-      const wordLength = word.word.length;
-      
-      minRow = Math.min(minRow, row);
-      minCol = Math.min(minCol, col);
-      
-      if (direction === 'horizontal') {
-        maxRow = Math.max(maxRow, row);
-        maxCol = Math.max(maxCol, col + wordLength - 1);
-      } else {
-        maxRow = Math.max(maxRow, row + wordLength - 1);
-        maxCol = Math.max(maxCol, col);
-      }
-    });
-    
-    // Add small padding
-    minRow = Math.max(0, minRow - 1);
-    minCol = Math.max(0, minCol - 1);
-    maxRow = Math.min(grid.length - 1, maxRow + 1);
-    maxCol = Math.min(grid[0].length - 1, maxCol + 1);
-    
-    // Create trimmed grid
-    const trimmedGrid = [];
-    for (let r = minRow; r <= maxRow; r++) {
-      const row = [];
-      for (let c = minCol; c <= maxCol; c++) {
-        row.push(grid[r][c]);
-      }
-      trimmedGrid.push(row);
-    }
-    
-    // Update placed words positions to match trimmed grid
-    const updatedPlacedWords = placedWords.map(word => ({
-      ...word,
-      row: word.row - minRow,
-      col: word.col - minCol
-    }));
-    
-    return { grid: trimmedGrid, placedWords: updatedPlacedWords };
-  }
-
-  placeWordsInGrid(words, size) {
-    const grid = Array(size).fill().map(() => Array(size).fill('.'));
-    const placedWords = [];
-    
-    const startTime = Date.now();
-    const timeout = 5000; // Reduced to 5 second timeout
-    
-    if (this.backtrackPlacement(grid, words, 0, placedWords, startTime, timeout)) {
-      const trimmed = this.trimGrid(grid, placedWords);
-      return { grid: trimmed.grid, placedWords: trimmed.placedWords };
-    }
-    
-    return null;
-  }
-
-  backtrackPlacement(grid, words, wordIndex, placedWords, startTime = Date.now(), timeout = 5000, callCount = 0) {
-    // Check timeout more frequently
-    if (callCount % 50 === 0 && Date.now() - startTime > timeout) {
-      console.error(`⏰ Placement timeout reached after ${Date.now() - startTime}ms`);
-      return false;
-    }
-
-    if (wordIndex >= words.length) {
-      return true;
-    }
-
-    const word = words[wordIndex];
-    const size = grid.length;
-
-    // For the first word, place the longest word in the center horizontally
-    if (wordIndex === 0) {
-      const centerRow = Math.floor(size / 2);
-      const centerCol = Math.floor((size - word.length) / 2);
-      
-      if (this.canPlaceWord(grid, word, centerRow, centerCol, 'horizontal')) {
-        const originalState = this.placeWord(grid, word, centerRow, centerCol, 'horizontal');
-        placedWords.push({ word, row: centerRow, col: centerCol, direction: 'horizontal', number: 1 });
-        
-        if (this.backtrackPlacement(grid, words, wordIndex + 1, placedWords, startTime, timeout, callCount + 1)) {
-          return true;
-        }
-        
-        this.removeWord(grid, originalState);
-        placedWords.pop();
-      }
-      return false;
-    }
-
-    // For the second word, try to create a central cross with smart selection
-    if (wordIndex === 1) {
-      const firstWord = placedWords[0];
-      
-      // Try all remaining words to find one that can intersect
-      const remainingWords = words.slice(1); // All words except the first
-      const wordsWithIntersections = [];
-      
-      // Score each remaining word by intersection potential
-      for (const candidateWord of remainingWords) {
-        const intersections = this.findWordIntersections(candidateWord, firstWord.word);
-        if (intersections.length > 0) {
-          wordsWithIntersections.push({
-            word: candidateWord,
-            intersectionCount: intersections.length,
-            intersections: intersections
-          });
-        }
-      }
-      
-      // Sort by intersection count (more intersections = better)
-      wordsWithIntersections.sort((a, b) => b.intersectionCount - a.intersectionCount);
-      
-      // Try each word with intersections
-      for (const candidateInfo of wordsWithIntersections) {
-        const candidateWord = candidateInfo.word;
-        
-        for (const intersection of candidateInfo.intersections) {
-          const placement = this.calculateIntersectionPlacement(candidateWord, intersection.wordPos, firstWord, intersection.placedPos);
-          
-          if (placement && this.canPlaceWord(grid, candidateWord, placement.row, placement.col, placement.direction)) {
-            const originalState = this.placeWord(grid, candidateWord, placement.row, placement.col, placement.direction);
-            placedWords.push({ word: candidateWord, ...placement, number: 2 });
-            
-            // Create new word order with the selected second word
-            const newWordOrder = [words[0], candidateWord, ...words.slice(1).filter(w => w !== candidateWord)];
-            
-            if (this.backtrackPlacement(grid, newWordOrder, wordIndex + 1, placedWords, startTime, timeout, callCount + 1)) {
-              return true;
-            }
-            
-            this.removeWord(grid, originalState);
-            placedWords.pop();
-          }
-        }
-      }
-      
-      return false;
-    }
-
-    // For subsequent words, find the best intersection opportunities
-    const allPlacements = this.findAllIntersectionPlacements(grid, word, placedWords);
-    
-    // Sort by intersection quality score
-    allPlacements.sort((a, b) => b.score - a.score);
-
-    // Try the best placements first
-    for (const placement of allPlacements) {
-      const { row, col, direction } = placement;
-      
-      if (this.canPlaceWord(grid, word, row, col, direction)) {
-        const originalState = this.placeWord(grid, word, row, col, direction);
-        placedWords.push({ word, row, col, direction, number: wordIndex + 1 });
-        
-        if (this.backtrackPlacement(grid, words, wordIndex + 1, placedWords, startTime, timeout, callCount + 1)) {
-          return true;
-        }
-        
-        this.removeWord(grid, originalState);
-        placedWords.pop();
-      }
-    }
-    
-    return false;
-  }
-
-  canPlaceWord(grid, word, row, col, direction) {
-    const size = grid.length;
-    
-    // Check boundaries first
-    if (row < 0 || col < 0 || row >= size || col >= size) {
-      return false;
-    }
-    
-    if (direction === 'horizontal') {
-      if (col + word.length > size) return false;
-      
-      for (let i = 0; i < word.length; i++) {
-        if (row >= size || col + i >= size || !grid[row] || grid[row][col + i] === undefined) {
-          return false;
-        }
-        const currentCell = grid[row][col + i];
-        if (currentCell !== '.' && currentCell !== word[i]) {
-          return false;
-        }
-      }
-    } else {
-      if (row + word.length > size) return false;
-      
-      for (let i = 0; i < word.length; i++) {
-        if (row + i >= size || col >= size || !grid[row + i] || grid[row + i][col] === undefined) {
-          return false;
-        }
-        const currentCell = grid[row + i][col];
-        if (currentCell !== '.' && currentCell !== word[i]) {
-          return false;
-        }
-      }
-    }
-    
-    return this.validateWordPlacement(grid, word, row, col, direction);
-  }
-
-  validateWordPlacement(grid, word, row, col, direction) {
-    const size = grid.length;
-    
-    if (direction === 'horizontal') {
-      // CRITICAL: Check word boundaries - no letters immediately before/after
-      if (col > 0 && grid[row][col - 1] !== '.') {
-        return false; // Word would have a preceding letter
-      }
-      if (col + word.length < size && grid[row][col + word.length] !== '.') {
-        return false; // Word would have a trailing letter
-      }
-      
-      // Check each letter position
-      for (let i = 0; i < word.length; i++) {
-        const currentCol = col + i;
-        const currentCell = grid[row][currentCol];
-        
-        // If cell is occupied, it must match the letter we're placing
-        if (currentCell !== '.' && currentCell !== word[i]) {
-          return false;
-        }
-        
-        // For empty cells, check perpendicular validity
-        if (currentCell === '.') {
-          // Check that placing this letter won't create invalid perpendicular words
-          if (!this.isValidPerpendicularPlacement(grid, word[i], row, currentCol, 'vertical')) {
-            return false;
-          }
-        }
-      }
-    } else { // vertical
-      // CRITICAL: Check word boundaries - no letters immediately before/after
-      if (row > 0 && grid[row - 1][col] !== '.') {
-        return false; // Word would have a preceding letter
-      }
-      if (row + word.length < size && grid[row + word.length][col] !== '.') {
-        return false; // Word would have a trailing letter
-      }
-      
-      // Check each letter position
-      for (let i = 0; i < word.length; i++) {
-        const currentRow = row + i;
-        const currentCell = grid[currentRow][col];
-        
-        // If cell is occupied, it must match the letter we're placing
-        if (currentCell !== '.' && currentCell !== word[i]) {
-          return false;
-        }
-        
-        // For empty cells, check perpendicular validity
-        if (currentCell === '.') {
-          // Check that placing this letter won't create invalid perpendicular words
-          if (!this.isValidPerpendicularPlacement(grid, word[i], currentRow, col, 'horizontal')) {
-            return false;
-          }
-        }
-      }
-    }
-    
-    return true;
-  }
-
-  placeWord(grid, word, row, col, direction) {
-    const originalState = [];
-    
-    if (direction === 'horizontal') {
-      for (let i = 0; i < word.length; i++) {
-        originalState.push({
-          row: row,
-          col: col + i,
-          value: grid[row][col + i]
-        });
-        grid[row][col + i] = word[i];
-      }
-    } else {
-      for (let i = 0; i < word.length; i++) {
-        originalState.push({
-          row: row + i,
-          col: col,
-          value: grid[row + i][col]
-        });
-        grid[row + i][col] = word[i];
-      }
-    }
-    
-    return originalState;
-  }
-
-  removeWord(grid, originalState) {
-    originalState.forEach(state => {
-      grid[state.row][state.col] = state.value;
-    });
-  }
-
-  generateClues(words, placedWords) {
-    return placedWords.map((placedWord, index) => {
-      // Find the word object that matches this placed word
-      const wordObj = words.find(w => w.word.toUpperCase() === placedWord.word);
-      
-      return {
-        number: index + 1,
-        word: placedWord.word,
-        text: wordObj ? (wordObj.clue || `Clue for ${placedWord.word}`) : `Clue for ${placedWord.word}`,
-        direction: placedWord.direction === 'horizontal' ? 'across' : 'down',
-        position: { row: placedWord.row, col: placedWord.col }
-      };
-    });
-  }
-
-  static validateAnswers(puzzle, userAnswers) {
-    const correct = {};
-    const incorrect = {};
-    let totalCorrect = 0;
-    let totalCells = 0;
-
-    puzzle.grid.forEach((row, rowIndex) => {
-      row.forEach((cell, colIndex) => {
-        if (cell !== '.') {
-          totalCells++;
-          const key = `${rowIndex}-${colIndex}`;
-          const userAnswer = userAnswers[key];
-          
-          if (userAnswer === cell) {
-            correct[key] = true;
-            totalCorrect++;
-          } else if (userAnswer) {
-            incorrect[key] = true;
-          }
-        }
-      });
-    });
-
-    return {
-      correct,
-      incorrect,
-      isComplete: totalCorrect === totalCells,
-      progress: totalCells > 0 ? (totalCorrect / totalCells) * 100 : 0
-    };
-  }
-
-  findAllIntersectionPlacements(grid, word, placedWords) {
-    const placements = [];
-    
-    // For each placed word, find potential intersections
-    for (const placedWord of placedWords) {
-      const intersections = this.findWordIntersections(word, placedWord.word);
-      
-      for (const intersection of intersections) {
-        const { wordPos, placedPos } = intersection;
-        
-        // Calculate where the new word would be placed
-        const placementInfo = this.calculateIntersectionPlacement(
-          word, wordPos, placedWord, placedPos
-        );
-        
-        if (placementInfo) {
-          // Calculate score for this placement
-          const score = this.calculatePlacementScore(grid, word, placementInfo, placedWords);
-          
-          placements.push({
-            ...placementInfo,
-            score,
-            intersectingWord: placedWord.word,
-            intersectionPoint: { wordPos, placedPos }
-          });
-        }
-      }
-    }
-    
-    return placements;
-  }
-
-  calculatePlacementScore(grid, word, placement, placedWords) {
-    const { row, col, direction } = placement;
-    let score = 0;
-    
-    // Base score for creating an intersection
-    score += 100;
-    
-    // Bonus for multiple intersections with the same word
-    let intersectionCount = 0;
-    
-    if (direction === 'horizontal') {
-      for (let i = 0; i < word.length; i++) {
-        const cellRow = row;
-        const cellCol = col + i;
-        
-        if (cellCol >= 0 && cellCol < grid.length && grid[cellRow] && grid[cellRow][cellCol] === word[i]) {
-          intersectionCount++;
-        }
-      }
-    } else {
-      for (let i = 0; i < word.length; i++) {
-        const cellRow = row + i;
-        const cellCol = col;
-        
-        if (cellRow >= 0 && cellRow < grid.length && grid[cellRow] && grid[cellRow][cellCol] === word[i]) {
-          intersectionCount++;
-        }
-      }
-    }
-    
-    // Multiple intersections are MUCH better
-    score += intersectionCount * 200;
-    
-    // Bonus for placing near the center
-    const center = Math.floor(grid.length / 2);
-    const distanceFromCenter = Math.abs(row - center) + Math.abs(col - center);
-    score -= distanceFromCenter * 5;
-    
-    // Bonus for connecting to multiple existing words
-    const adjacentWords = this.countAdjacentWords(grid, word, row, col, direction, placedWords);
-    score += adjacentWords * 50;
-    
-    // Prefer compact layouts - bonus for being close to existing words
-    const proximityBonus = this.calculateProximityBonus(grid, row, col, direction, word.length);
-    score += proximityBonus;
-    
-    return score;
-  }
-
-  countAdjacentWords(grid, word, row, col, direction, placedWords) {
-    let adjacentCount = 0;
-    const size = grid.length;
-    
-    if (direction === 'horizontal') {
-      for (let i = 0; i < word.length; i++) {
-        const cellRow = row;
-        const cellCol = col + i;
-        
-        // Check boundaries before accessing array
-        if (cellRow < 0 || cellRow >= size || cellCol < 0 || cellCol >= size) continue;
-        
-        // Check above and below
-        if (cellRow > 0 && grid[cellRow - 1] && grid[cellRow - 1][cellCol] && grid[cellRow - 1][cellCol] !== '.') {
-          adjacentCount++;
-        }
-        if (cellRow < size - 1 && grid[cellRow + 1] && grid[cellRow + 1][cellCol] && grid[cellRow + 1][cellCol] !== '.') {
-          adjacentCount++;
-        }
-      }
-    } else {
-      for (let i = 0; i < word.length; i++) {
-        const cellRow = row + i;
-        const cellCol = col;
-        
-        // Check boundaries before accessing array
-        if (cellRow < 0 || cellRow >= size || cellCol < 0 || cellCol >= size) continue;
-        
-        // Check left and right
-        if (cellCol > 0 && grid[cellRow] && grid[cellRow][cellCol - 1] && grid[cellRow][cellCol - 1] !== '.') {
-          adjacentCount++;
-        }
-        if (cellCol < size - 1 && grid[cellRow] && grid[cellRow][cellCol + 1] && grid[cellRow][cellCol + 1] !== '.') {
-          adjacentCount++;
-        }
-      }
-    }
-    
-    return adjacentCount;
-  }
-
-  calculateProximityBonus(grid, row, col, direction, wordLength) {
-    let cellsNearOtherWords = 0;
-    const size = grid.length;
-    
-    if (direction === 'horizontal') {
-      for (let i = 0; i < wordLength; i++) {
-        const cellCol = col + i;
-        
-        // Check surrounding cells for letters
-        for (let dr = -1; dr <= 1; dr++) {
-          for (let dc = -1; dc <= 1; dc++) {
-            const checkRow = row + dr;
-            const checkCol = cellCol + dc;
-            
-            if (checkRow >= 0 && checkRow < size && 
-                checkCol >= 0 && checkCol < size &&
-                grid[checkRow] && grid[checkRow][checkCol] &&
-                grid[checkRow][checkCol] !== '.') {
-              cellsNearOtherWords++;
-            }
-          }
-        }
-      }
-    } else {
-      for (let i = 0; i < wordLength; i++) {
-        const cellRow = row + i;
-        
-        // Check surrounding cells for letters
-        for (let dr = -1; dr <= 1; dr++) {
-          for (let dc = -1; dc <= 1; dc++) {
-            const checkRow = cellRow + dr;
-            const checkCol = col + dc;
-            
-            if (checkRow >= 0 && checkRow < size && 
-                checkCol >= 0 && checkCol < size &&
-                grid[checkRow] && grid[checkRow][checkCol] &&
-                grid[checkRow][checkCol] !== '.') {
-              cellsNearOtherWords++;
-            }
-          }
-        }
-      }
-    }
-    
-    return cellsNearOtherWords * 10;
-  }
-
-  findIntersectionPlacements(grid, word, placedWords) {
-    return this.findAllIntersectionPlacements(grid, word, placedWords);
-  }
-
-  findWordIntersections(word1, word2) {
-    const intersections = [];
-    
-    for (let i = 0; i < word1.length; i++) {
-      for (let j = 0; j < word2.length; j++) {
-        if (word1[i] === word2[j]) {
-          intersections.push({
-            wordPos: i,    // Position in the new word
-            placedPos: j   // Position in the already placed word
-          });
-        }
-      }
-    }
-    
-    return intersections;
-  }
-
-  calculateIntersectionPlacement(newWord, newWordPos, placedWord, placedWordPos) {
-    const { row: placedRow, col: placedCol, direction: placedDirection } = placedWord;
-    
-    // Calculate the position of the intersecting letter in the grid
-    let intersectionRow, intersectionCol;
-    
-    if (placedDirection === 'horizontal') {
-      intersectionRow = placedRow;
-      intersectionCol = placedCol + placedWordPos;
-    } else {
-      intersectionRow = placedRow + placedWordPos;
-      intersectionCol = placedCol;
-    }
-    
-    // Calculate where the new word should start
-    const newDirection = placedDirection === 'horizontal' ? 'vertical' : 'horizontal';
-    
-    let newRow, newCol;
-    
-    if (newDirection === 'horizontal') {
-      newRow = intersectionRow;
-      newCol = intersectionCol - newWordPos;
-    } else {
-      newRow = intersectionRow - newWordPos;
-      newCol = intersectionCol;
-    }
-    
-    return {
-      row: newRow,
-      col: newCol,
-      direction: newDirection
-    };
-  }
-
-  findFallbackPlacements(grid, word, size) {
-    const placements = [];
-    
-    // Generate some positions near the center
-    const center = Math.floor(size / 2);
-    const searchRadius = Math.min(3, Math.floor(size / 4));
-    
-    for (let r = center - searchRadius; r <= center + searchRadius; r++) {
-      for (let c = center - searchRadius; c <= center + searchRadius; c++) {
-        if (r >= 0 && c >= 0 && r < size && c < size) {
-          for (const direction of ['horizontal', 'vertical']) {
-            placements.push({ row: r, col: c, direction });
-          }
-        }
-      }
-    }
-    
-    return placements;
-  }
-
-  countIntersections(grid, word, row, col, direction) {
-    let intersections = 0;
-    
-    if (direction === 'horizontal') {
-      for (let i = 0; i < word.length; i++) {
-        if (grid[row][col + i] === word[i]) {
-          intersections++;
-        }
-      }
-    } else {
-      for (let i = 0; i < word.length; i++) {
-        if (grid[row + i][col] === word[i]) {
-          intersections++;
-        }
-      }
-    }
-    
-    return intersections;
-  }
-
-  wouldConnect(grid, word, row, col, direction, placedWords) {
-    if (placedWords.length === 0) return true; // First word always connects
-    
-    // Check if this word would intersect with any placed word
-    if (direction === 'horizontal') {
-      for (let i = 0; i < word.length; i++) {
-        if (grid[row][col + i] !== '.') {
-          return true; // Intersects with existing letter
-        }
-        // Check if adjacent to existing letters (forming a connection)
-        if ((row > 0 && grid[row - 1][col + i] !== '.') ||
-            (row < grid.length - 1 && grid[row + 1][col + i] !== '.')) {
-          return true;
-        }
-      }
-    } else {
-      for (let i = 0; i < word.length; i++) {
-        if (grid[row + i][col] !== '.') {
-          return true; // Intersects with existing letter
-        }
-        // Check if adjacent to existing letters (forming a connection)
-        if ((col > 0 && grid[row + i][col - 1] !== '.') ||
-            (col < grid[0].length - 1 && grid[row + i][col + 1] !== '.')) {
-          return true;
-        }
-      }
-    }
-    
-    return false;
-  }
-
-  isValidPerpendicularPlacement(grid, letter, row, col, checkDirection) {
-    const size = grid.length;
-    
-    if (checkDirection === 'vertical') {
-      // Check if placing this letter would create an invalid vertical sequence
-      let hasAbove = row > 0 && grid[row - 1] && grid[row - 1][col] !== '.';
-      let hasBelow = row < size - 1 && grid[row + 1] && grid[row + 1][col] !== '.';
-      
-      // STRICT: Don't allow this letter to be placed if it would extend an existing vertical word
-      // unless it's exactly at an intersection point with matching letters
-      if (hasAbove || hasBelow) {
-        // Only allow if this letter is exactly matching existing intersections
-        return grid[row][col] === letter;
-      }
-    } else { // horizontal
-      // Check if placing this letter would create an invalid horizontal sequence
-      let hasLeft = col > 0 && grid[row] && grid[row][col - 1] !== '.';
-      let hasRight = col < size - 1 && grid[row] && grid[row][col + 1] !== '.';
-      
-      // STRICT: Don't allow this letter to be placed if it would extend an existing horizontal word
-      // unless it's exactly at an intersection point with matching letters
-      if (hasLeft || hasRight) {
-        // Only allow if this letter is exactly matching existing intersections
-        return grid[row][col] === letter;
-      }
-    }
-    
-    return true;
-  }
-
-  isValidCrossing(grid, letter, row, col) {
-    // This method should only be called for exact intersections
-    // where the letter already exists in the grid
-    return grid[row] && grid[row][col] === letter;
-  }
-
-  createSimpleCross(words) {
-    // Find the best intersection between the two words
-    const word1 = words[0];
-    const word2 = words[1];
-    const intersections = this.findWordIntersections(word1, word2);
-    
-    if (intersections.length === 0) {
-      console.error(`❌ No intersections found between ${word1} and ${word2}`);
-      return null;
-    }
-    
-    // Use the first intersection
-    const intersection = intersections[0];
-    const size = Math.max(word1.length, word2.length) + 4;
-    const grid = Array(size).fill().map(() => Array(size).fill('.'));
-    
-    // Place first word horizontally in center
-    const centerRow = Math.floor(size / 2);
-    const centerCol = Math.floor((size - word1.length) / 2);
-    
-    for (let i = 0; i < word1.length; i++) {
-      grid[centerRow][centerCol + i] = word1[i];
-    }
-    
-    // Place second word vertically at intersection
-    const intersectionCol = centerCol + intersection.wordPos;
-    const word2StartRow = centerRow - intersection.placedPos;
-    
-    for (let i = 0; i < word2.length; i++) {
-      grid[word2StartRow + i][intersectionCol] = word2[i];
-    }
-    
-    const placedWords = [
-      { word: word1, row: centerRow, col: centerCol, direction: 'horizontal', number: 1 },
-      { word: word2, row: word2StartRow, col: intersectionCol, direction: 'vertical', number: 2 }
-    ];
-    
-    const trimmed = this.trimGrid(grid, placedWords);
-    return { grid: trimmed.grid, size: trimmed.grid.length, placedWords: trimmed.placedWords };
-  }
-
-  shuffleArray(array) {
-    const shuffled = [...array];
-    for (let i = shuffled.length - 1; i > 0; i--) {
-      const j = Math.floor(Math.random() * (i + 1));
-      [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
-    }
-    return shuffled;
-  }
-
-  logWordClueMapping(words, useAI, topics) {
-    const source = useAI ? 'AI-generated' : 'Static';
-    const topicsList = Array.isArray(topics) ? topics.join(', ') : topics;
-    console.log(`\n📝 Word->Clue Mapping (${source}) for topics: ${topicsList}`);
-    console.log('════════════════════════════════════════');
-    
-    // Create a formatted table of word->clue mappings
-    const wordClueMap = {};
-    words.forEach(wordObj => {
-      const word = wordObj.word || wordObj;
-      const clue = wordObj.clue || 'No clue available';
-      wordClueMap[word] = clue;
-    });
-
-    // Sort by word length for better readability
-    const sortedWords = Object.keys(wordClueMap).sort((a, b) => a.length - b.length);
-    
-    sortedWords.forEach((word, index) => {
-      const clue = wordClueMap[word];
-      const paddedWord = word.padEnd(15, ' ');
-      console.log(`${(index + 1).toString().padStart(2, ' ')}. ${paddedWord} -> ${clue}`);
-    });
-    
-    console.log('════════════════════════════════════════');
-    console.log(`Total words: ${words.length}\n`);
-  }
-}
-
-module.exports = CrosswordGenerator;

crossword-app/backend/src/services/embeddingWordService.js

@@ -1,635 +0,0 @@
-const { HfInference } = require('@huggingface/inference');
-const WordService = require('./wordService');
-
-// Store original console methods
-const originalLog = console.log;
-const originalWarn = console.warn;
-
-// Helper to suppress HF verbose messages
-function suppressHFLogs(fn) {
-  return async (...args) => {
-    console.log = (...msgs) => {
-      const msg = msgs.join(' ');
-      if (!msg.includes('Defaulting to') && !msg.includes('Auto selected provider')) {
-        originalLog(...msgs);
-      }
-    };
-    console.warn = (...msgs) => {
-      const msg = msgs.join(' ');
-      if (!msg.includes('Defaulting to') && !msg.includes('Auto selected provider')) {
-        originalWarn(...msgs);
-      }
-    };
-    
-    try {
-      const result = await fn(...args);
-      return result;
-    } finally {
-      console.log = originalLog;
-      console.warn = originalWarn;
-    }
-  };
-}
-
-class EmbeddingWordService {
-  constructor() {
-    this.hf = null;
-    this.isInitialized = false;
-    this.embeddingCache = new Map();
-    this.wordCache = new Map();
-    this.fallbackToStatic = process.env.FALLBACK_TO_STATIC === 'true';
-    this.maxWordsPerGeneration = parseInt(process.env.MAX_WORDS_PER_GENERATION) || 15;
-    this.similarityThreshold = parseFloat(process.env.WORD_SIMILARITY_THRESHOLD) || 0.65;
-    this.maxTopicWords = parseInt(process.env.MAX_TOPIC_WORDS) || 50;
-    
-    // console.log(`🔧 EmbeddingWordService initialized with fallback: ${this.fallbackToStatic}`);
-    
-    // Initialize HuggingFace client
-    this.initializeHF();
-  }
-
-  async initializeHF() {
-    try {
-      const apiKey = process.env.HUGGINGFACE_API_KEY;
-      if (!apiKey || apiKey === 'hf_xxxxxxxxxx') {
-        console.warn('⚠️ HuggingFace API key not configured, falling back to static words');
-        this.isInitialized = false;
-        return;
-      }
-
-      // Configure HuggingFace client with minimal logging
-      this.hf = new HfInference(apiKey, {
-        use_cache: true,
-        dont_load_model: false
-      });
-      
-      // Test the connection with a simple embedding request
-      await this.testConnection();
-      this.isInitialized = true;
-      console.log('✅ HuggingFace Embedding Service initialized successfully');
-      
-    } catch (error) {
-      console.error('❌ Failed to initialize HuggingFace service:', error.message);
-      this.isInitialized = false;
-    }
-  }
-
-  async testConnection() {
-    const testConnectionInternal = async () => {
-      return await this.hf.featureExtraction({
-        model: process.env.EMBEDDING_MODEL || 'sentence-transformers/all-MiniLM-L6-v2',
-        inputs: 'test'
-      });
-    };
-
-    try {
-      const testEmbedding = await suppressHFLogs(testConnectionInternal)();
-      
-      if (!testEmbedding || testEmbedding.length === 0) {
-        throw new Error('Empty embedding response');
-      }
-      console.log(`✅ HF Embedding test successful - vector dimension: ${testEmbedding.length}`);
-      return true;
-    } catch (error) {
-      console.error('❌ HuggingFace connection test failed:', error.message);
-      throw error;
-    }
-  }
-
-  async getEmbedding(text) {
-    if (!this.isInitialized || !this.hf) {
-      throw new Error('HuggingFace service not initialized');
-    }
-
-    // Check cache first
-    const cacheKey = text.toLowerCase().trim();
-    if (this.embeddingCache.has(cacheKey)) {
-      return this.embeddingCache.get(cacheKey);
-    }
-
-    const getEmbeddingInternal = async () => {
-      return await this.hf.featureExtraction({
-        model: process.env.EMBEDDING_MODEL || 'sentence-transformers/all-MiniLM-L6-v2',
-        inputs: text
-      });
-    };
-
-    try {
-      const embedding = await suppressHFLogs(getEmbeddingInternal)();
-
-      // Cache the embedding
-      if (process.env.CACHE_EMBEDDINGS === 'true') {
-        this.embeddingCache.set(cacheKey, embedding);
-        
-        // Limit cache size to prevent memory issues
-        if (this.embeddingCache.size > 1000) {
-          const firstKey = this.embeddingCache.keys().next().value;
-          this.embeddingCache.delete(firstKey);
-        }
-      }
-
-      return embedding;
-      
-    } catch (error) {
-      console.error(`❌ Failed to get embedding for "${text}":`, error.message);
-      throw error;
-    }
-  }
-
-  calculateCosineSimilarity(vecA, vecB) {
-    if (!vecA || !vecB || vecA.length !== vecB.length) {
-      return 0;
-    }
-
-    let dotProduct = 0;
-    let normA = 0;
-    let normB = 0;
-
-    for (let i = 0; i < vecA.length; i++) {
-      dotProduct += vecA[i] * vecB[i];
-      normA += vecA[i] * vecA[i];
-      normB += vecB[i] * vecB[i];
-    }
-
-    if (normA === 0 || normB === 0) {
-      return 0;
-    }
-
-    return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
-  }
-
-  async generateWordsForTopics(topics, difficulty = 'medium', targetCount = 12) {
-    try {
-      // If HF is not initialized, fall back to static words
-      if (!this.isInitialized && this.fallbackToStatic) {
-        console.log('🔄 Using static word fallback');
-        return await this.getStaticWordsForTopics(topics, difficulty, targetCount);
-      }
-
-      if (!this.isInitialized) {
-        throw new Error('HuggingFace service not available and fallback disabled');
-      }
-
-      console.log(`🔍 Generating words for topics: ${topics.join(', ')} (difficulty: ${difficulty})`);
-
-      // Get topic embeddings
-      const topicEmbeddings = await Promise.all(
-        topics.map(async (topic) => ({
-          topic,
-          embedding: await this.getEmbedding(topic)
-        }))
-      );
-
-      // Generate diverse word candidates
-      const candidates = await this.generateWordCandidates(topicEmbeddings, difficulty);
-
-      // Score and filter words for crossword suitability
-      const scoredWords = this.scoreWordsForCrossword(candidates);
-
-      // Select best words up to target count
-      const selectedWords = scoredWords.slice(0, targetCount);
-
-      // If we don't have enough words, supplement with static words
-      if (selectedWords.length < targetCount && this.fallbackToStatic) {
-        console.log(`🔄 Only found ${selectedWords.length} AI words, supplementing with static words`);
-        const staticWords = await this.getStaticWordsForTopics(topics, difficulty, targetCount - selectedWords.length);
-        selectedWords.push(...staticWords);
-      }
-
-      console.log(`✅ Generated ${selectedWords.length} words for crossword`);
-      return selectedWords.slice(0, targetCount);
-
-    } catch (error) {
-      console.error('❌ Error generating words with embeddings:', error.message);
-      
-      if (this.fallbackToStatic) {
-        console.log('🔄 Falling back to static words due to error');
-        return await this.getStaticWordsForTopics(topics, difficulty, targetCount);
-      }
-      
-      throw error;
-    }
-  }
-
-  async generateWordCandidates(topicEmbeddings, difficulty) {
-    const candidates = new Set();
-    
-    // TRUE AI GENERATION: Generate words directly using text generation
-    for (const { topic } of topicEmbeddings) {
-      const generatedWords = await this.generateWordsForTopic(topic, difficulty);
-      generatedWords.forEach(wordObj => candidates.add(wordObj));
-    }
-
-    console.log(`🤖 Generated ${candidates.size} AI words for topics`);
-
-    // Only if AI generation completely fails, fall back to static words
-    if (candidates.size === 0) {
-      console.log(`⚠️ AI generation failed, falling back to static words`);
-      for (const { topic, embedding } of topicEmbeddings) {
-        const staticWords = await this.findSimilarWords(topic, embedding, difficulty);
-        staticWords.forEach(word => candidates.add({ word, clue: `Static clue for ${word}` }));
-      }
-    }
-
-    return Array.from(candidates);
-  }
-
-  async generateWordsForTopic(topic, difficulty) {
-    try {
-      // Use comprehensive topic-specific word banks instead of LLM generation
-      const topicWords = this.getTopicSpecificWords(topic, difficulty);
-      
-      if (topicWords.length === 0) {
-        console.log(`⚠️ No words found for topic "${topic}", falling back to prompts`);
-        // Fallback to LLM generation if needed
-        return await this.generateWordsFromPrompts(topic, difficulty);
-      }
-
-      // Randomly select and shuffle words for variety
-      const shuffled = this.shuffleArray(topicWords);
-      const selected = shuffled.slice(0, Math.min(15, topicWords.length));
-      
-      console.log(`🎯 Generated ${selected.length} topic-specific words for "${topic}"`);
-      return selected;
-    } catch (error) {
-      console.error(`❌ Failed to generate words for topic "${topic}":`, error.message);
-      return [];
-    }
-  }
-
-  getTopicSpecificWords(topic, difficulty) {
-    // Comprehensive topic-specific word banks - TRUE GENERATION!
-    const topicBanks = {
-      'Animals': {
-        easy: [
-          { word: 'CAT', clue: 'Feline pet' },
-          { word: 'DOG', clue: 'Canine companion' },
-          { word: 'BIRD', clue: 'Flying creature' },
-          { word: 'FISH', clue: 'Swimming creature' },
-          { word: 'BEAR', clue: 'Large forest mammal' },
-          { word: 'LION', clue: 'King of jungle' },
-          { word: 'WOLF', clue: 'Pack hunter' },
-          { word: 'DEER', clue: 'Antlered mammal' },
-          { word: 'FROG', clue: 'Pond jumper' },
-          { word: 'SNAKE', clue: 'Slithering reptile' }
-        ],
-        medium: [
-          { word: 'TIGER', clue: 'Striped big cat' },
-          { word: 'WHALE', clue: 'Largest marine mammal' },
-          { word: 'EAGLE', clue: 'Soaring predator' },
-          { word: 'SHARK', clue: 'Ocean predator' },
-          { word: 'ZEBRA', clue: 'Striped African animal' },
-          { word: 'GIRAFFE', clue: 'Tallest mammal' },
-          { word: 'ELEPHANT', clue: 'Largest land mammal' },
-          { word: 'PENGUIN', clue: 'Antarctic bird' },
-          { word: 'OCTOPUS', clue: 'Eight-armed sea creature' },
-          { word: 'DOLPHIN', clue: 'Intelligent marine mammal' },
-          { word: 'RABBIT', clue: 'Hopping mammal' },
-          { word: 'TURTLE', clue: 'Shelled reptile' },
-          { word: 'MONKEY', clue: 'Primate swinger' },
-          { word: 'PARROT', clue: 'Colorful talking bird' }
-        ],
-        hard: [
-          { word: 'RHINOCEROS', clue: 'Horned thick-skinned mammal' },
-          { word: 'HIPPOPOTAMUS', clue: 'River horse' },
-          { word: 'CHIMPANZEE', clue: 'Human-like primate' },
-          { word: 'ORANGUTAN', clue: 'Red-haired ape' },
-          { word: 'CROCODILE', clue: 'Large aquatic reptile' },
-          { word: 'CHAMELEON', clue: 'Color-changing lizard' },
-          { word: 'FLAMINGO', clue: 'Pink wading bird' },
-          { word: 'KANGAROO', clue: 'Hopping marsupial' },
-          { word: 'PLATYPUS', clue: 'Egg-laying mammal' }
-        ]
-      },
-      'Technology': {
-        easy: [
-          { word: 'PHONE', clue: 'Mobile device' },
-          { word: 'MOUSE', clue: 'Computer pointer' },
-          { word: 'SCREEN', clue: 'Display surface' },
-          { word: 'CABLE', clue: 'Connecting wire' },
-          { word: 'VIRUS', clue: 'Malicious software' },
-          { word: 'EMAIL', clue: 'Digital message' },
-          { word: 'WIFI', clue: 'Wireless internet' },
-          { word: 'CHIP', clue: 'Computer processor' }
-        ],
-        medium: [
-          { word: 'COMPUTER', clue: 'Electronic processor' },
-          { word: 'KEYBOARD', clue: 'Input device with keys' },
-          { word: 'MONITOR', clue: 'Computer display screen' },
-          { word: 'SOFTWARE', clue: 'Computer programs' },
-          { word: 'HARDWARE', clue: 'Physical components' },
-          { word: 'DATABASE', clue: 'Organized data storage' },
-          { word: 'NETWORK', clue: 'Connected systems' },
-          { word: 'INTERNET', clue: 'Global network' },
-          { word: 'BROWSER', clue: 'Web navigation tool' },
-          { word: 'SERVER', clue: 'Data hosting computer' },
-          { word: 'LAPTOP', clue: 'Portable computer' },
-          { word: 'TABLET', clue: 'Touch screen device' },
-          { word: 'ROUTER', clue: 'Network traffic director' },
-          { word: 'PRINTER', clue: 'Document output device' }
-        ],
-        hard: [
-          { word: 'ALGORITHM', clue: 'Problem-solving procedure' },
-          { word: 'CYBERSECURITY', clue: 'Digital protection field' },
-          { word: 'BLOCKCHAIN', clue: 'Distributed ledger technology' },
-          { word: 'ARTIFICIAL', clue: 'Man-made intelligence type' },
-          { word: 'PROGRAMMING', clue: 'Code writing process' },
-          { word: 'ENCRYPTION', clue: 'Data scrambling method' },
-          { word: 'SEMICONDUCTOR', clue: 'Electronic component material' }
-        ]
-      },
-      'Science': {
-        easy: [
-          { word: 'ATOM', clue: 'Smallest unit of matter' },
-          { word: 'GENE', clue: 'Heredity unit' },
-          { word: 'ACID', clue: 'Chemical solution' },
-          { word: 'LENS', clue: 'Light focusing tool' },
-          { word: 'WAVE', clue: 'Energy transmission' },
-          { word: 'MOON', clue: 'Earth\'s satellite' },
-          { word: 'STAR', clue: 'Celestial light source' }
-        ],
-        medium: [
-          { word: 'MOLECULE', clue: 'Chemical compound unit' },
-          { word: 'GRAVITY', clue: 'Attractive force' },
-          { word: 'ELECTRON', clue: 'Negative particle' },
-          { word: 'PROTEIN', clue: 'Complex biological molecule' },
-          { word: 'CARBON', clue: 'Element in all life' },
-          { word: 'OXYGEN', clue: 'Breathing gas' },
-          { word: 'NEUTRON', clue: 'Neutral atomic particle' },
-          { word: 'ENERGY', clue: 'Capacity to do work' },
-          { word: 'GALAXY', clue: 'Star system collection' },
-          { word: 'PLANET', clue: 'Orbiting celestial body' },
-          { word: 'CRYSTAL', clue: 'Ordered solid structure' },
-          { word: 'ENZYME', clue: 'Biological catalyst' }
-        ],
-        hard: [
-          { word: 'PHOTOSYNTHESIS', clue: 'Plant energy conversion' },
-          { word: 'CHROMOSOME', clue: 'DNA carrying structure' },
-          { word: 'THERMODYNAMICS', clue: 'Heat and energy study' },
-          { word: 'ELECTROMAGNETIC', clue: 'Electric and magnetic field' },
-          { word: 'QUANTUM', clue: 'Smallest energy unit' },
-          { word: 'BIOCHEMISTRY', clue: 'Chemical life processes' }
-        ]
-      },
-      'Geography': {
-        easy: [
-          { word: 'HILL', clue: 'Small elevation' },
-          { word: 'LAKE', clue: 'Body of water' },
-          { word: 'RIVER', clue: 'Flowing water' },
-          { word: 'OCEAN', clue: 'Large sea' },
-          { word: 'ISLAND', clue: 'Land surrounded by water' },
-          { word: 'BEACH', clue: 'Sandy shore' },
-          { word: 'FOREST', clue: 'Dense tree area' }
-        ],
-        medium: [
-          { word: 'MOUNTAIN', clue: 'High elevation landform' },
-          { word: 'VOLCANO', clue: 'Erupting mountain' },
-          { word: 'DESERT', clue: 'Arid landscape' },
-          { word: 'CANYON', clue: 'Deep valley' },
-          { word: 'PLATEAU', clue: 'Elevated flatland' },
-          { word: 'GLACIER', clue: 'Moving ice mass' },
-          { word: 'PENINSULA', clue: 'Land jutting into water' },
-          { word: 'CONTINENT', clue: 'Large landmass' },
-          { word: 'ARCHIPELAGO', clue: 'Island chain' },
-          { word: 'TUNDRA', clue: 'Arctic plains' },
-          { word: 'SAVANNA', clue: 'Tropical grassland' },
-          { word: 'ESTUARY', clue: 'River mouth' }
-        ],
-        hard: [
-          { word: 'TOPOGRAPHY', clue: 'Land surface features' },
-          { word: 'CARTOGRAPHY', clue: 'Map making science' },
-          { word: 'PRECIPITATION', clue: 'Weather moisture' },
-          { word: 'CONTINENTAL', clue: 'Large landmass related' },
-          { word: 'ECOSYSTEM', clue: 'Environmental system' }
-        ]
-      }
-    };
-
-    const topicKey = Object.keys(topicBanks).find(key => 
-      key.toLowerCase() === topic.toLowerCase()
-    );
-
-    if (!topicKey) {
-      console.log(`⚠️ No word bank found for topic: ${topic}`);
-      return [];
-    }
-
-    const difficultyWords = topicBanks[topicKey][difficulty] || topicBanks[topicKey]['medium'] || [];
-    return difficultyWords;
-  }
-
-  async generateWordsFromPrompt(prompt, topic) {
-    const generateTextInternal = async () => {
-      return await this.hf.textGeneration({
-        model: 'microsoft/DialoGPT-medium',
-        inputs: prompt,
-        parameters: {
-          max_new_tokens: 150,
-          temperature: 0.8,
-          do_sample: true,
-          repetition_penalty: 1.2
-        }
-      });
-    };
-
-    try {
-      const response = await suppressHFLogs(generateTextInternal)();
-      const generatedText = response.generated_text || '';
-      
-      // Extract words from the generated text
-      const words = this.extractWordsFromGeneration(generatedText, topic);
-      return words;
-    } catch (error) {
-      console.error(`❌ Text generation failed for prompt:`, error.message);
-      return [];
-    }
-  }
-
-  extractWordsFromGeneration(text, topic) {
-    const words = [];
-    
-    // Extract potential words from the generated text
-    const lines = text.split('\n');
-    const wordPattern = /\b[A-Z]{3,15}\b/g;
-    
-    for (const line of lines) {
-      const matches = line.match(wordPattern) || [];
-      for (const word of matches) {
-        if (this.isValidCrosswordWord(word)) {
-          words.push({
-            word: word.toUpperCase(),
-            clue: this.generateSimpleClue(word, topic)
-          });
-        }
-      }
-    }
-
-    // Remove duplicates and limit to reasonable number
-    const uniqueWords = Array.from(new Set(words.map(w => w.word)))
-      .slice(0, 10)
-      .map(word => words.find(w => w.word === word));
-
-    return uniqueWords;
-  }
-
-  isValidCrosswordWord(word) {
-    // Check if word is suitable for crossword
-    return (
-      word.length >= 3 && 
-      word.length <= 15 && 
-      /^[A-Z]+$/.test(word) && 
-      !['THE', 'AND', 'FOR', 'ARE', 'BUT', 'NOT', 'YOU', 'ALL'].includes(word)
-    );
-  }
-
-  generateSimpleClue(word, topic) {
-    // Generate basic clues based on word and topic
-    const clueTemplates = {
-      'Animals': `${word.toLowerCase()} (animal)`,
-      'Technology': `${word.toLowerCase()} (tech term)`,
-      'Science': `${word.toLowerCase()} (scientific term)`,
-      'Geography': `${word.toLowerCase()} (geographic feature)`
-    };
-
-    return clueTemplates[topic] || `${word.toLowerCase()} (${topic.toLowerCase()})`;
-  }
-
-  async findSimilarWords(topic, topicEmbedding, difficulty) {
-    const similarWords = [];
-    
-    // Get static words for this topic as candidates
-    const staticWords = await WordService.getWordsByTopic(topic);
-    
-    for (const wordObj of staticWords.slice(0, this.maxTopicWords)) {
-      try {
-        const word = wordObj.word;
-        const wordEmbedding = await this.getEmbedding(word);
-        const similarity = this.calculateCosineSimilarity(topicEmbedding, wordEmbedding);
-        
-        if (similarity >= this.similarityThreshold) {
-          similarWords.push({
-            word: word,
-            clue: wordObj.clue,
-            similarity: similarity,
-            topic: topic
-          });
-        }
-      } catch (error) {
-        // Skip words that fail embedding generation
-        continue;
-      }
-    }
-
-    // Sort by similarity and return more top words for better variety
-    return similarWords
-      .sort((a, b) => b.similarity - a.similarity)
-      .slice(0, 20)
-      .map(item => item.word);
-  }
-
-  scoreWordsForCrossword(words) {
-    return words.map(wordItem => {
-      let score = 0;
-      
-      // Handle both string words and word objects
-      const wordObj = typeof wordItem === 'string' ? { word: wordItem, clue: `Generated clue for ${wordItem}` } : wordItem;
-      const wordUpper = wordObj.word.toUpperCase();
-      
-      // Length scoring (prefer 4-8 character words)
-      if (wordUpper.length >= 4 && wordUpper.length <= 8) {
-        score += 10;
-      } else if (wordUpper.length >= 3 && wordUpper.length <= 10) {
-        score += 5;
-      }
-
-      // Common letters bonus
-      const commonLetters = ['E', 'A', 'R', 'I', 'O', 'T', 'N', 'S'];
-      for (const letter of wordUpper) {
-        if (commonLetters.includes(letter)) {
-          score += 1;
-        }
-      }
-
-      // Vowel distribution
-      const vowels = ['A', 'E', 'I', 'O', 'U'];
-      const vowelCount = wordUpper.split('').filter(letter => vowels.includes(letter)).length;
-      score += vowelCount * 2;
-
-      // Avoid problematic characters
-      if (!/^[A-Z]+$/.test(wordUpper)) {
-        score -= 20; // Penalty for non-alphabetic characters
-      }
-
-      return {
-        word: wordUpper,
-        clue: wordObj.clue || `Generated clue for ${wordUpper}`,
-        score: score
-      };
-    })
-    .filter(item => item.score > 0) // Remove words with negative scores
-    .sort((a, b) => b.score - a.score); // Sort by score descending
-  }
-
-  async getStaticWordsForTopics(topics, difficulty, targetCount) {
-    try {
-      const allWords = [];
-      
-      for (const topic of topics) {
-        const topicWords = await WordService.getWordsByTopic(topic);
-        allWords.push(...topicWords);
-      }
-
-      // Filter by difficulty
-      const filteredWords = this.filterWordsByDifficulty(allWords, difficulty);
-      
-      // Shuffle and select target count
-      const shuffled = this.shuffleArray(filteredWords);
-      return shuffled.slice(0, targetCount);
-      
-    } catch (error) {
-      console.error('❌ Error getting static words:', error.message);
-      throw error;
-    }
-  }
-
-  filterWordsByDifficulty(words, difficulty) {
-    const difficultyMap = {
-      easy: { minLen: 3, maxLen: 8 },
-      medium: { minLen: 4, maxLen: 10 },
-      hard: { minLen: 5, maxLen: 15 }
-    };
-    
-    const { minLen, maxLen } = difficultyMap[difficulty] || difficultyMap.medium;
-    
-    return words.filter(word => 
-      word.word.length >= minLen && word.word.length <= maxLen
-    );
-  }
-
-  shuffleArray(array) {
-    const shuffled = [...array];
-    for (let i = shuffled.length - 1; i > 0; i--) {
-      const j = Math.floor(Math.random() * (i + 1));
-      [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
-    }
-    return shuffled;
-  }
-
-  // Utility methods for cache management
-  clearCache() {
-    this.embeddingCache.clear();
-    this.wordCache.clear();
-    console.log('🧹 Embedding and word caches cleared');
-  }
-
-  getCacheStats() {
-    return {
-      embeddingCacheSize: this.embeddingCache.size,
-      wordCacheSize: this.wordCache.size,
-      isInitialized: this.isInitialized,
-      fallbackEnabled: this.fallbackToStatic
-    };
-  }
-}
-
-module.exports = new EmbeddingWordService();

crossword-app/backend/src/services/wordService.js

@@ -1,131 +0,0 @@
-const fs = require('fs').promises;
-const path = require('path');
-
-class WordService {
-  constructor() {
-    this.wordsCache = new Map();
-    this.topicsCache = null;
-  }
-
-  async getAllTopics() {
-    if (this.topicsCache) {
-      return this.topicsCache;
-    }
-
-    try {
-      const dataDir = path.join(__dirname, '../../data/word-lists');
-      const files = await fs.readdir(dataDir);
-      
-      const topics = files
-        .filter(file => file.endsWith('.json'))
-        .map(file => ({
-          id: file.replace('.json', ''),
-          name: this.formatTopicName(file.replace('.json', ''))
-        }));
-
-      this.topicsCache = topics;
-      return topics;
-    } catch (error) {
-      console.error('Error loading topics:', error);
-      return this.getDefaultTopics();
-    }
-  }
-
-  async getWordsByTopic(topicName) {
-    const cacheKey = topicName.toLowerCase();
-    
-    if (this.wordsCache.has(cacheKey)) {
-      return this.wordsCache.get(cacheKey);
-    }
-
-    try {
-      const filePath = path.join(__dirname, '../../data/word-lists', `${topicName.toLowerCase()}.json`);
-      const fileContent = await fs.readFile(filePath, 'utf8');
-      const words = JSON.parse(fileContent);
-      
-      this.wordsCache.set(cacheKey, words);
-      return words;
-    } catch (error) {
-      console.error(`Error loading words for topic ${topicName}:`, error);
-      return this.getDefaultWords(topicName);
-    }
-  }
-
-  formatTopicName(fileName) {
-    return fileName
-      .split('-')
-      .map(word => word.charAt(0).toUpperCase() + word.slice(1))
-      .join(' ');
-  }
-
-  getDefaultTopics() {
-    return [
-      { id: 'animals', name: 'Animals' },
-      { id: 'geography', name: 'Geography' },
-      { id: 'science', name: 'Science' },
-      { id: 'technology', name: 'Technology' },
-      { id: 'sports', name: 'Sports' },
-      { id: 'history', name: 'History' },
-      { id: 'food', name: 'Food' },
-      { id: 'entertainment', name: 'Entertainment' },
-      { id: 'nature', name: 'Nature' },
-      { id: 'transportation', name: 'Transportation' },
-      { id: 'art', name: 'Art' },
-      { id: 'medicine', name: 'Medicine' }
-    ];
-  }
-
-  getDefaultWords(topic) {
-    const defaultWordSets = {
-      animals: [
-        { word: 'DOG', clue: 'Man\'s best friend' },
-        { word: 'CAT', clue: 'Feline pet' },
-        { word: 'ELEPHANT', clue: 'Large mammal with trunk' },
-        { word: 'TIGER', clue: 'Striped big cat' },
-        { word: 'WHALE', clue: 'Largest marine mammal' },
-        { word: 'BUTTERFLY', clue: 'Colorful flying insect' },
-        { word: 'BIRD', clue: 'Flying creature with feathers' },
-        { word: 'FISH', clue: 'Aquatic animal with gills' }
-      ],
-      science: [
-        { word: 'ATOM', clue: 'Smallest unit of matter' },
-        { word: 'GRAVITY', clue: 'Force that pulls objects down' },
-        { word: 'MOLECULE', clue: 'Group of atoms bonded together' },
-        { word: 'PHOTON', clue: 'Particle of light' },
-        { word: 'CHEMISTRY', clue: 'Study of matter and reactions' },
-        { word: 'PHYSICS', clue: 'Study of matter and energy' },
-        { word: 'BIOLOGY', clue: 'Study of living organisms' },
-        { word: 'ELEMENT', clue: 'Pure chemical substance' }
-      ],
-      geography: [
-        { word: 'MOUNTAIN', clue: 'High elevation landform' },
-        { word: 'OCEAN', clue: 'Large body of salt water' },
-        { word: 'DESERT', clue: 'Dry, arid region' },
-        { word: 'CONTINENT', clue: 'Large landmass' },
-        { word: 'RIVER', clue: 'Flowing body of water' },
-        { word: 'ISLAND', clue: 'Land surrounded by water' },
-        { word: 'FOREST', clue: 'Dense area of trees' },
-        { word: 'VALLEY', clue: 'Low area between hills' }
-      ],
-      technology: [
-        { word: 'COMPUTER', clue: 'Electronic processing device' },
-        { word: 'INTERNET', clue: 'Global computer network' },
-        { word: 'ALGORITHM', clue: 'Set of rules for solving problems' },
-        { word: 'DATABASE', clue: 'Organized collection of data' },
-        { word: 'SOFTWARE', clue: 'Computer programs' },
-        { word: 'ROBOT', clue: 'Automated machine' },
-        { word: 'NETWORK', clue: 'Connected system of computers' },
-        { word: 'CODE', clue: 'Programming instructions' }
-      ]
-    };
-
-    return defaultWordSets[topic.toLowerCase()] || [];
-  }
-
-  clearCache() {
-    this.wordsCache.clear();
-    this.topicsCache = null;
-  }
-}
-
-module.exports = new WordService();

crossword-app/backend/src/test-ai-integration.js

@@ -1,116 +0,0 @@
-#!/usr/bin/env node
-
-// Test script to demonstrate AI integration capabilities
-require('dotenv').config();
-
-const axios = require('axios').default || require('axios');
-
-const BASE_URL = 'http://localhost:3001/api';
-
-async function testAIIntegration() {
-  console.log('🧪 Testing AI Integration - Phase 6.1 Complete!\n');
-
-  try {
-    // Test 1: Check AI service status
-    console.log('1️⃣ Testing AI Service Status...');
-    const statusResponse = await axios.get(`${BASE_URL}/ai/status`);
-    const status = statusResponse.data;
-    
-    console.log(`   ✅ AI Service Status: ${status.status}`);
-    console.log(`   🤖 HF Initialized: ${status.aiService.initialized}`);
-    console.log(`   🔄 Fallback Enabled: ${status.aiService.fallbackEnabled}`);
-    console.log(`   📊 Cache Size: ${status.aiService.cacheStats.embeddingCache} embeddings\n`);
-
-    // Test 2: AI Word Generation
-    console.log('2️⃣ Testing AI Word Generation...');
-    const wordsResponse = await axios.post(`${BASE_URL}/ai/generate-words`, {
-      topics: ['animals', 'science'],
-      difficulty: 'medium',
-      count: 8
-    });
-    
-    const wordsData = wordsResponse.data;
-    console.log(`   ✅ Generated ${wordsData.generatedCount} words`);
-    console.log(`   🧠 AI Generated: ${wordsData.aiGenerated}`);
-    console.log(`   📝 Sample words:`, wordsData.words.slice(0, 3).map(w => w.word).join(', '));
-    console.log();
-
-    // Test 3: Enhanced Puzzle Generation (Static)
-    console.log('3️⃣ Testing Enhanced Puzzle Generation (Static)...');
-    const puzzleStaticResponse = await axios.post(`${BASE_URL}/generate`, {
-      topics: ['technology'],
-      difficulty: 'medium',
-      useAI: false
-    });
-    
-    const puzzleStatic = puzzleStaticResponse.data;
-    console.log(`   ✅ Generated puzzle with ${puzzleStatic.metadata.wordCount} words`);
-    console.log(`   🧠 AI Generated: ${puzzleStatic.metadata.aiGenerated}`);
-    console.log(`   📐 Grid Size: ${puzzleStatic.metadata.size}x${puzzleStatic.metadata.size}`);
-    console.log();
-
-    // Test 4: Enhanced Puzzle Generation (AI Fallback)
-    console.log('4️⃣ Testing Enhanced Puzzle Generation (AI with Fallback)...');
-    const puzzleAIResponse = await axios.post(`${BASE_URL}/generate`, {
-      topics: ['geography'],
-      difficulty: 'medium',
-      useAI: true
-    });
-    
-    const puzzleAI = puzzleAIResponse.data;
-    console.log(`   ✅ Generated puzzle with ${puzzleAI.metadata.wordCount} words`);
-    console.log(`   🧠 AI Generated: ${puzzleAI.metadata.aiGenerated}`);
-    console.log(`   📐 Grid Size: ${puzzleAI.metadata.size}x${puzzleAI.metadata.size}`);
-    console.log();
-
-    // Test 5: Performance Comparison
-    console.log('5️⃣ Performance Test...');
-    const startTime = Date.now();
-    
-    await axios.post(`${BASE_URL}/ai/generate-words`, {
-      topics: ['animals'],
-      difficulty: 'easy',
-      count: 6
-    });
-    
-    const endTime = Date.now();
-    console.log(`   ⚡ Word generation took: ${endTime - startTime}ms`);
-    console.log();
-
-    console.log('✅ All AI Integration Tests Passed!\n');
-    
-    console.log('📋 Phase 6.1 Summary:');
-    console.log('   ✅ HuggingFace dependencies installed');
-    console.log('   ✅ Environment variables configured');
-    console.log('   ✅ EmbeddingWordService class created');
-    console.log('   ✅ Graceful fallback to static words');
-    console.log('   ✅ New AI endpoints working');
-    console.log('   ✅ Enhanced puzzle generation');
-    console.log('   ✅ Performance and error handling');
-    console.log();
-    
-    console.log('🚀 Next Steps (Phase 6.2):');
-    console.log('   1. Sign up for HuggingFace account');
-    console.log('   2. Get API token and update HUGGINGFACE_API_KEY');
-    console.log('   3. Test real AI-powered word generation');
-    console.log('   4. Implement dynamic clue generation');
-    console.log('   5. Add Redis caching layer');
-
-  } catch (error) {
-    console.error('❌ Test failed:', error.message);
-    if (error.response) {
-      console.error('   Status:', error.response.status);
-      console.error('   Data:', error.response.data);
-    }
-    console.error('\n💡 Make sure the server is running on port 3001');
-    console.error('   Run: npm run dev');
-  }
-}
-
-// Check if axios is available
-if (typeof axios === 'undefined') {
-  console.log('⚠️  axios not installed - install with: npm install axios');
-  console.log('   or test manually with curl commands');
-} else {
-  testAIIntegration();
-}

crossword-app/backend/src/test-embedding.js

@@ -1,63 +0,0 @@
-#!/usr/bin/env node
-
-// Test script for EmbeddingWordService
-require('dotenv').config();
-const EmbeddingWordService = require('./services/embeddingWordService');
-
-async function testEmbeddingService() {
-  console.log('🧪 Testing EmbeddingWordService...\n');
-
-  try {
-    // Test 1: Check service initialization
-    console.log('1️⃣ Testing service initialization...');
-    const stats = EmbeddingWordService.getCacheStats();
-    console.log('   Service stats:', stats);
-    
-    if (stats.isInitialized) {
-      console.log('   ✅ HuggingFace service initialized successfully');
-    } else {
-      console.log('   ⚠️  HuggingFace service not initialized (likely missing API key)');
-      console.log('   📝 This is expected if HUGGINGFACE_API_KEY is not set');
-    }
-
-    // Test 2: Generate words for topics
-    console.log('\n2️⃣ Testing word generation...');
-    const topics = ['animals', 'science'];
-    const words = await EmbeddingWordService.generateWordsForTopics(topics, 'medium', 8);
-    
-    console.log(`   Generated ${words.length} words for topics: ${topics.join(', ')}`);
-    words.forEach((word, index) => {
-      console.log(`   ${index + 1}. ${word.word} - "${word.clue}"`);
-    });
-
-    // Test 3: Test different difficulties
-    console.log('\n3️⃣ Testing different difficulties...');
-    const difficulties = ['easy', 'medium', 'hard'];
-    
-    for (const difficulty of difficulties) {
-      const diffWords = await EmbeddingWordService.generateWordsForTopics(['technology'], difficulty, 3);
-      console.log(`   ${difficulty.toUpperCase()}: ${diffWords.map(w => w.word).join(', ')}`);
-    }
-
-    // Test 4: Cache stats
-    console.log('\n4️⃣ Final cache stats...');
-    const finalStats = EmbeddingWordService.getCacheStats();
-    console.log('   Final stats:', finalStats);
-
-    console.log('\n✅ All tests completed successfully!');
-    
-    // Instructions for next steps
-    console.log('\n📋 Next Steps:');
-    console.log('   1. Sign up for HuggingFace account at https://huggingface.co/join');
-    console.log('   2. Generate API token at https://huggingface.co/settings/tokens');
-    console.log('   3. Update HUGGINGFACE_API_KEY in .env file');
-    console.log('   4. Run this test again to verify AI-powered word generation');
-
-  } catch (error) {
-    console.error('❌ Test failed:', error.message);
-    console.error('   Stack trace:', error.stack);
-  }
-}
-
-// Run the test
-testEmbeddingService();