Add SEO fields to Tasks model, improve content generation response handling, and enhance progress bar animation

- Added primary_keyword, secondary_keywords, tags, and categories fields to Tasks model
- Updated generate_content function to handle full JSON response with all SEO fields
- Improved progress bar animation: smooth 1% increments every 300ms
- Enhanced step detection for content generation vs clustering vs ideas
- Fixed progress modal to show correct messages for each function type
- Added comprehensive logging to Keywords and Tasks pages for AI functions
- Fixed error handling to show meaningful error messages instead of generic failures

backend/igny8_core/ai/tracker.py

@@ -4,7 +4,9 @@ Progress and Step Tracking utilities for AI framework
 import time
 import logging
 from typing import List, Dict, Any, Optional, Callable
+from datetime import datetime
 from igny8_core.ai.types import StepLog, ProgressState
+from igny8_core.ai.constants import DEBUG_MODE
 
 logger = logging.getLogger(__name__)
 
@@ -221,3 +223,100 @@ class CostTracker:
         """Get all operations"""
         return self.operations
 
+
+class ConsoleStepTracker:
+    """
+    Lightweight console-based step tracker for AI functions.
+    Logs each step to console with timestamps and clear labels.
+    Only logs if DEBUG_MODE is True.
+    """
+    
+    def __init__(self, function_name: str):
+        self.function_name = function_name
+        self.start_time = time.time()
+        self.steps = []
+        self.current_phase = None
+    
+    def _log(self, phase: str, message: str, status: str = 'info'):
+        """Internal logging method that checks DEBUG_MODE"""
+        if not DEBUG_MODE:
+            return
+        
+        timestamp = datetime.now().strftime('%H:%M:%S')
+        phase_label = phase.upper()
+        
+        if status == 'error':
+            print(f"[{timestamp}] [{self.function_name}] [{phase_label}] [ERROR] {message}")
+        elif status == 'success':
+            print(f"[{timestamp}] [{self.function_name}] [{phase_label}] ✅ {message}")
+        else:
+            print(f"[{timestamp}] [{self.function_name}] [{phase_label}] {message}")
+        
+        self.steps.append({
+            'timestamp': timestamp,
+            'phase': phase,
+            'message': message,
+            'status': status
+        })
+        self.current_phase = phase
+    
+    def init(self, message: str = "Task started"):
+        """Log initialization phase"""
+        self._log('INIT', message)
+    
+    def prep(self, message: str):
+        """Log preparation phase"""
+        self._log('PREP', message)
+    
+    def ai_call(self, message: str):
+        """Log AI call phase"""
+        self._log('AI_CALL', message)
+    
+    def parse(self, message: str):
+        """Log parsing phase"""
+        self._log('PARSE', message)
+    
+    def save(self, message: str):
+        """Log save phase"""
+        self._log('SAVE', message)
+    
+    def done(self, message: str = "Execution completed"):
+        """Log completion"""
+        duration = time.time() - self.start_time
+        self._log('DONE', f"{message} (Duration: {duration:.2f}s)", status='success')
+        if DEBUG_MODE:
+            print(f"[{self.function_name}] === AI Task Complete ===")
+    
+    def error(self, error_type: str, message: str, exception: Exception = None):
+        """Log error with standardized format"""
+        error_msg = f"{error_type} – {message}"
+        if exception:
+            error_msg += f" ({type(exception).__name__})"
+        self._log(self.current_phase or 'ERROR', error_msg, status='error')
+        if DEBUG_MODE and exception:
+            import traceback
+            print(f"[{self.function_name}] [ERROR] Stack trace:")
+            traceback.print_exc()
+    
+    def retry(self, attempt: int, max_attempts: int, reason: str = ""):
+        """Log retry attempt"""
+        msg = f"Retry attempt {attempt}/{max_attempts}"
+        if reason:
+            msg += f" – {reason}"
+        self._log('AI_CALL', msg, status='info')
+    
+    def timeout(self, timeout_seconds: int):
+        """Log timeout"""
+        self.error('Timeout', f"Request timeout after {timeout_seconds}s")
+    
+    def rate_limit(self, retry_after: str):
+        """Log rate limit"""
+        self.error('RateLimit', f"OpenAI rate limit hit, retry in {retry_after}s")
+    
+    def malformed_json(self, details: str = ""):
+        """Log JSON parsing error"""
+        msg = "Failed to parse model response: Unexpected JSON"
+        if details:
+            msg += f" – {details}"
+        self.error('MalformedJSON', msg)
+