Fix server binding and reduce verbose logging for production deployment

- Bind server to 0.0.0.0 in production for external connections (fixes HF Spaces connectivity)
- Add debug logging for working directory and app location in production
- Remove verbose crossword generation logs, keep only error messages
- Streamline backtracking placement logging for better performance

Signed-off-by: Vimal Kumar <vimal78@gmail.com>

crossword-app/backend/src/app.js

@@ -115,9 +115,12 @@ app.use((error, req, res, next) => {
 });
 
 if (require.main === module) {
-  app.listen(PORT, () => {
-    console.log(`Server running on port ${PORT}`);
+  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`);

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

@@ -8,30 +8,23 @@ class CrosswordGenerator {
   }
 
   async generatePuzzle(topics, difficulty = 'medium') {
-    console.log(`🎯 Starting puzzle generation - Topics: ${JSON.stringify(topics)}, Difficulty: ${difficulty}`);
-    
     try {
       const words = await this.selectWords(topics, difficulty);
-      console.log(`📚 Selected ${words.length} words for puzzle:`, words.map(w => w.word).join(', '));
       
       if (words.length < this.minWords) {
-        console.log(`❌ Not enough words: ${words.length} < ${this.minWords}`);
+        console.error(`❌ Not enough words: ${words.length} < ${this.minWords}`);
         throw new Error('Not enough words available for selected topics');
       }
 
-      console.log(`🔧 Starting grid creation with ${words.length} words`);
       const gridResult = this.createGrid(words);
       
       if (!gridResult) {
-        console.log(`❌ Grid creation failed - could not place words`);
+        console.error(`❌ Grid creation failed - could not place words`);
         throw new Error('Could not place words in grid');
       }
-
-      console.log(`✅ Grid created successfully - Size: ${gridResult.size}x${gridResult.size}, Words placed: ${gridResult.placedWords.length}`);
       
       const clues = this.generateClues(words, gridResult.placedWords);
       
-      console.log(`🎉 Puzzle generation completed successfully!`);
       return {
         grid: gridResult.grid,
         clues: clues,
@@ -122,48 +115,40 @@ class CrosswordGenerator {
 
   createGrid(words) {
     if (!words || words.length === 0) {
-      console.log(`❌ No words provided to createGrid`);
+      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);
-    console.log(`📐 Calculated grid size: ${size}x${size} for words:`, wordList.join(', '));
     
     // Try with different grid sizes and word counts
     for (let attempt = 0; attempt < 3; attempt++) {
       const currentSize = size + attempt;
-      console.log(`🔍 Attempt ${attempt + 1}: Trying grid size ${currentSize}x${currentSize} with ${wordList.length} words`);
       
       // First try with all words
       let result = this.placeWordsInGrid(wordList, currentSize);
       if (result) {
-        console.log(`✅ Success with all ${wordList.length} words on size ${currentSize}x${currentSize}`);
         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);
-        console.log(`🔄 Retrying with ${reducedWords.length} words:`, reducedWords.join(', '));
         result = this.placeWordsInGrid(reducedWords, currentSize);
         if (result) {
-          console.log(`✅ Success with ${reducedWords.length} words on size ${currentSize}x${currentSize}`);
           return { grid: result.grid, size: currentSize, placedWords: result.placedWords };
         }
       }
     }
     
     // Only as last resort, try with minimum words
-    console.log(`🚨 Fallback: Trying with minimum 6 words`);
     for (let attempt = 0; attempt < 2; attempt++) {
       const currentSize = size + attempt;
       if (wordList.length >= 6) {
         const minWords = wordList.slice(0, 6);
-        console.log(`🔄 Last resort attempt ${attempt + 1}: ${minWords.length} words on ${currentSize}x${currentSize}:`, minWords.join(', '));
         const result = this.placeWordsInGrid(minWords, currentSize);
         if (result) {
-          console.log(`✅ Success with minimum ${minWords.length} words on size ${currentSize}x${currentSize}`);
           return { grid: result.grid, size: currentSize, placedWords: result.placedWords };
         }
       }
@@ -171,14 +156,13 @@ class CrosswordGenerator {
     
     // Absolute last resort: simple cross pattern with just 2 words
     if (wordList.length >= 2) {
-      console.log(`🆘 Emergency fallback: Simple 2-word cross pattern`);
       const result = this.createSimpleCross(wordList.slice(0, 2));
       if (result) {
         return result;
       }
     }
     
-    console.log(`❌ All grid creation attempts failed`);
+    console.error(`❌ All grid creation attempts failed`);
     return null;
   }
 
@@ -242,53 +226,40 @@ class CrosswordGenerator {
   }
 
   placeWordsInGrid(words, size) {
-    console.log(`🎲 Creating ${size}x${size} grid for words:`, words.join(', '));
     const grid = Array(size).fill().map(() => Array(size).fill('.'));
     const placedWords = [];
     
-    console.log(`🔄 Starting backtrack placement...`);
     const startTime = Date.now();
     const timeout = 5000; // Reduced to 5 second timeout
     
     if (this.backtrackPlacement(grid, words, 0, placedWords, startTime, timeout)) {
-      console.log(`✅ Backtracking successful! Placed ${placedWords.length} words`);
       const trimmed = this.trimGrid(grid, placedWords);
-      console.log(`📏 Grid trimmed to ${trimmed.grid.length}x${trimmed.grid[0].length}`);
       return { grid: trimmed.grid, placedWords: trimmed.placedWords };
     }
     
-    console.log(`❌ Backtracking failed for ${size}x${size} grid (timeout or no solution)`);
     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.log(`⏰ Timeout reached after ${Date.now() - startTime}ms (${callCount} calls)`);
+      console.error(`⏰ Placement timeout reached after ${Date.now() - startTime}ms`);
       return false;
     }
 
     if (wordIndex >= words.length) {
-      console.log(`🎉 All ${words.length} words placed successfully!`);
       return true;
     }
 
     const word = words[wordIndex];
     const size = grid.length;
-    
-    // Limit excessive logging for performance
-    if (callCount % 50 === 0 || wordIndex <= 2) {
-      console.log(`🔤 Placing word ${wordIndex + 1}/${words.length}: "${word}" (${word.length} chars) [call ${callCount}]`);
-    }
 
     // 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);
-      console.log(`📍 First word "${word}": trying center position (${centerRow}, ${centerCol}) horizontal`);
       
       if (this.canPlaceWord(grid, word, centerRow, centerCol, 'horizontal')) {
-        console.log(`✅ First word "${word}" placed at center`);
         const originalState = this.placeWord(grid, word, centerRow, centerCol, 'horizontal');
         placedWords.push({ word, row: centerRow, col: centerCol, direction: 'horizontal', number: 1 });
         
@@ -296,11 +267,8 @@ class CrosswordGenerator {
           return true;
         }
         
-        console.log(`🔙 Backtracking from first word "${word}"`);
         this.removeWord(grid, originalState);
         placedWords.pop();
-      } else {
-        console.log(`❌ Cannot place first word "${word}" at center`);
       }
       return false;
     }
@@ -308,7 +276,6 @@ class CrosswordGenerator {
     // For the second word, try to create a central cross with smart selection
     if (wordIndex === 1) {
       const firstWord = placedWords[0];
-      console.log(`🔍 Smart second word selection - trying to find word that intersects with "${firstWord.word}"`);
       
       // Try all remaining words to find one that can intersect
       const remainingWords = words.slice(1); // All words except the first
@@ -328,41 +295,31 @@ class CrosswordGenerator {
       
       // Sort by intersection count (more intersections = better)
       wordsWithIntersections.sort((a, b) => b.intersectionCount - a.intersectionCount);
-      console.log(`📊 Found ${wordsWithIntersections.length} words with intersections:`, 
-        wordsWithIntersections.map(w => `${w.word}(${w.intersectionCount})`).join(', '));
       
       // Try each word with intersections
       for (const candidateInfo of wordsWithIntersections) {
         const candidateWord = candidateInfo.word;
-        console.log(`🔍 Trying second word "${candidateWord}" with ${candidateInfo.intersectionCount} intersections`);
         
         for (const intersection of candidateInfo.intersections) {
           const placement = this.calculateIntersectionPlacement(candidateWord, intersection.wordPos, firstWord, intersection.placedPos);
-          console.log(`🎯 Trying intersection at word[${intersection.wordPos}] = placed[${intersection.placedPos}], placement:`, placement);
           
           if (placement && this.canPlaceWord(grid, candidateWord, placement.row, placement.col, placement.direction)) {
-            console.log(`✅ Valid placement found for "${candidateWord}"`);
             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)];
-            console.log(`🔄 New word order:`, newWordOrder.join(', '));
             
             if (this.backtrackPlacement(grid, newWordOrder, wordIndex + 1, placedWords, startTime, timeout, callCount + 1)) {
               return true;
             }
             
-            console.log(`🔙 Backtracking from second word "${candidateWord}"`);
             this.removeWord(grid, originalState);
             placedWords.pop();
-          } else {
-            console.log(`❌ Invalid placement for "${candidateWord}" at`, placement);
           }
         }
       }
       
-      console.log(`❌ No valid second word found with intersections`);
       return false;
     }
 
@@ -901,15 +858,13 @@ class CrosswordGenerator {
   }
 
   createSimpleCross(words) {
-    console.log(`🛠️ Creating simple cross with: ${words.join(', ')}`);
-    
     // 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.log(`❌ No intersections found between ${word1} and ${word2}`);
+      console.error(`❌ No intersections found between ${word1} and ${word2}`);
       return null;
     }
     
@@ -940,7 +895,6 @@ class CrosswordGenerator {
     ];
     
     const trimmed = this.trimGrid(grid, placedWords);
-    console.log(`✅ Simple cross created successfully`);
     return { grid: trimmed.grid, size: trimmed.grid.length, placedWords: trimmed.placedWords };
   }