update canvas

multi_llm_chatbot_backend/app/api/routes/chat_sessions.py

@@ -222,6 +222,30 @@ async def save_message_to_session(
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
             detail="Could not save message"
         )
+    
+@router.get("/chat-sessions/count")
+async def get_chat_sessions_count(
+    current_user: User = Depends(get_current_active_user)
+):
+    """Get count of user's chat sessions"""
+    try:
+        db = get_database()
+        user_object_id = ObjectId(str(current_user.id))
+        
+        count = await db.chat_sessions.count_documents({
+            "user_id": user_object_id,
+            "is_active": {"$ne": False},
+            "deleted_at": {"$exists": False}
+        })
+        
+        return {"count": count}
+        
+    except Exception as e:
+        logger.error(f"Error counting chat sessions for user {current_user.id}: {e}")
+        raise HTTPException(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail="Failed to count chat sessions"
+        )
 
 @router.delete("/chat-sessions/{session_id}")
 async def delete_chat_session(

multi_llm_chatbot_backend/app/api/routes/phd_canvas.py

@@ -175,26 +175,55 @@ async def trigger_auto_update(
         if not canvas.auto_update:
             return {"message": "Auto-update is disabled for this canvas"}
         
+        # Check if this is a first-time canvas (never processed any chats)
+        is_first_time_canvas = (
+            canvas.last_chat_processed is None and 
+            canvas.total_insights == 0
+        )
+        
         # Check if we need to update (has been more than 1 hour since last update)
         from datetime import timedelta
-        needs_update = (
+        needs_regular_update = (
             canvas.last_updated is None or 
             (datetime.utcnow() - canvas.last_updated) > timedelta(hours=1)
         )
         
-        if needs_update:
-            logger.info(f"Auto-updating canvas for user {current_user.id}")
+        if is_first_time_canvas:
+            logger.info(f"First-time canvas detected for user {current_user.id}, triggering full update")
+            
+            # For first-time canvas, always do full update to process all historical chats
+            background_tasks.add_task(
+                _background_canvas_update,
+                str(current_user.id),
+                UpdateCanvasRequest(force_full_update=True)
+            )
+            
+            return {
+                "message": "First-time canvas update initiated", 
+                "status": "processing",
+                "type": "full_update"
+            }
+            
+        elif needs_regular_update:
+            logger.info(f"Regular auto-updating canvas for user {current_user.id}")
             
-            # Queue incremental update in background
+            # For existing canvas, do incremental update
             background_tasks.add_task(
                 _background_canvas_update,
                 str(current_user.id),
                 UpdateCanvasRequest(force_full_update=False)
             )
             
-            return {"message": "Canvas update queued", "status": "updating"}
+            return {
+                "message": "Canvas update queued", 
+                "status": "updating",
+                "type": "incremental_update"
+            }
         else:
-            return {"message": "Canvas is up to date", "status": "current"}
+            return {
+                "message": "Canvas is up to date", 
+                "status": "current"
+            }
             
     except Exception as e:
         logger.error(f"Error triggering auto-update for user {current_user.id}: {e}")

multi_llm_chatbot_backend/app/core/canvas_manager.py

@@ -5,7 +5,6 @@ from bson import ObjectId
 
 from app.models.phd_canvas import PhdCanvas, CanvasInsight, UpdateCanvasRequest
 from app.core.canvas_analysis import CanvasAnalysisService
-# Remove this import: from app.core.database import get_database
 from app.core.bootstrap import llm
 
 logger = logging.getLogger(__name__)
@@ -63,6 +62,17 @@ class CanvasManager:
             
             logger.info(f"Updating canvas for user {user_id}, force_full={request.force_full_update}")
             
+            # IMPORTANT: Auto-detect if this should be a full update for first-time canvas
+            is_first_time_update = (
+                canvas.last_chat_processed is None and 
+                canvas.total_insights == 0 and
+                not request.force_full_update
+            )
+            
+            if is_first_time_update:
+                logger.info(f"Auto-detecting first-time canvas update for user {user_id}. Converting to full update.")
+                request.force_full_update = True
+            
             # Determine which chats to process
             if request.force_full_update:
                 # Process all chats
@@ -193,12 +203,22 @@ class CanvasManager:
                     {"updated_at": {"$gt": since}}
                 ]
             else:
-                # If no since time, get chats from last 7 days as default
-                one_week_ago = datetime.utcnow() - timedelta(days=7)
-                query_filter["created_at"] = {"$gte": one_week_ago}
+                # IMPORTANT FIX: If no since time and this is being called for incremental update,
+                # we should still get more chats for proper first-time processing
+                # The caller should handle the force_full_update logic properly
+                
+                # For now, get chats from last 30 days instead of 7 as a safer fallback
+                # But ideally, first-time canvas should always use force_full_update=True
+                one_month_ago = datetime.utcnow() - timedelta(days=30)
+                query_filter["created_at"] = {"$gte": one_month_ago}
+                
+                logger.warning(f"Getting new chat sessions for user {user_id} with no 'since' timestamp. "
+                             f"This should only happen for incremental updates. Consider using force_full_update=True for first-time canvas.")
             
+            # Increase limit for incremental updates to catch more historical chats
+            limit = 100  # Increased from 50
             cursor = db.chat_sessions.find(query_filter).sort("created_at", -1)
-            chat_sessions = await cursor.to_list(length=50)  # Limit for incremental updates
+            chat_sessions = await cursor.to_list(length=limit)
             
             return chat_sessions
             

phd-advisor-frontend/src/pages/CanvasPage.js

@@ -92,11 +92,21 @@ const CanvasPage = ({ user, authToken, onNavigateToChat, onSignOut }) => {
   const [expandedSections, setExpandedSections] = useState({});
   const [stats, setStats] = useState({});
   const [isPrintView, setIsPrintView] = useState(false);
+  const [isProcessingFirstTime, setIsProcessingFirstTime] = useState(false);
 
   useEffect(() => {
-    fetchCanvas();
-    fetchStats();
-    triggerAutoUpdate();
+    const initializeCanvas = async () => {
+      await fetchCanvas();
+      await fetchStats();
+      await triggerAutoUpdate();
+      
+      // After initial load, check if we need to populate empty canvas
+      setTimeout(() => {
+        checkForEmptyCanvasWithChats();
+      }, 2000); // Wait 2 seconds after initial load
+    };
+    
+    initializeCanvas();
   }, []);
 
   const fetchCanvas = async () => {
@@ -148,15 +158,87 @@ const CanvasPage = ({ user, authToken, onNavigateToChat, onSignOut }) => {
     }
   };
 
+  // Check if user has chats but empty canvas
+  const checkForEmptyCanvasWithChats = async () => {
+    try {
+      // Check if canvas is empty (no insights)
+      const isEmpty = !canvasData || canvasData.total_insights === 0;
+      
+      if (isEmpty) {
+        // Check if user has any chat sessions
+        const response = await fetch(`${process.env.REACT_APP_API_URL}/api/chat-sessions/count`, {
+          headers: {
+            'Authorization': `Bearer ${authToken}`,
+            'Content-Type': 'application/json'
+          }
+        });
+        
+        if (response.ok) {
+          const { count } = await response.json();
+          
+          if (count > 0) {
+            // User has chats but empty canvas - trigger full refresh
+            console.log(`User has ${count} chats but empty canvas. Triggering full refresh.`);
+            await handleFullRefresh();
+          }
+        }
+      }
+    } catch (error) {
+      console.error('Error checking for empty canvas with chats:', error);
+    }
+  };
+
   const triggerAutoUpdate = async () => {
     try {
-      await fetch(`${process.env.REACT_APP_API_URL}/api/phd-canvas/auto-update`, {
+      const response = await fetch(`${process.env.REACT_APP_API_URL}/api/phd-canvas/auto-update`, {
         method: 'POST',
         headers: {
           'Authorization': `Bearer ${authToken}`,
           'Content-Type': 'application/json'
         }
       });
+      
+      if (response.ok) {
+        const result = await response.json();
+        
+        // If this is a first-time canvas update, show appropriate message
+        if (result.type === 'full_update') {
+          console.log('First-time canvas detected. Processing all your chats...');
+          
+          // Show loading state
+          setIsProcessingFirstTime(true);
+          setIsUpdating(true);
+          
+          // Poll for updates every 10 seconds for up to 3 minutes
+          let attempts = 0;
+          const maxAttempts = 18; // 3 minutes / 10 seconds
+          
+          const pollForUpdates = setInterval(async () => {
+            attempts++;
+            
+            try {
+              await fetchCanvas();
+              
+              // If canvas now has insights, stop polling
+              if (canvasData && canvasData.total_insights > 0) {
+                clearInterval(pollForUpdates);
+                setIsUpdating(false);
+                setIsProcessingFirstTime(false);
+                console.log('Canvas successfully populated with insights!');
+              }
+              
+              // Stop polling after max attempts
+              if (attempts >= maxAttempts) {
+                clearInterval(pollForUpdates);
+                setIsUpdating(false);
+                setIsProcessingFirstTime(false);
+              }
+            } catch (error) {
+              console.error('Error polling for updates:', error);
+            }
+          }, 10000);
+        }
+      }
     } catch (error) {
       console.error('Error triggering auto-update:', error);
     }
@@ -174,15 +256,52 @@ const CanvasPage = ({ user, authToken, onNavigateToChat, onSignOut }) => {
       });
 
       if (response.ok) {
-        // Wait a moment then refresh the canvas
+        const result = await response.json();
+        console.log('Full refresh initiated:', result);
+        
+        // Poll for updates
         setTimeout(() => {
           fetchCanvas();
           fetchStats();
-        }, 2000);
+        }, 5000);
+        
+        setTimeout(() => {
+          setIsUpdating(false);
+        }, 10000);
+      }
+    } catch (error) {
+      console.error('Error refreshing canvas:', error);
+      setIsUpdating(false);
+    }
+  };
+
+  const handleFullRefresh = async () => {
+    setIsUpdating(true);
+    try {
+      const response = await fetch(`${process.env.REACT_APP_API_URL}/api/phd-canvas/refresh`, {
+        method: 'GET',
+        headers: {
+          'Authorization': `Bearer ${authToken}`,
+          'Content-Type': 'application/json'
+        }
+      });
+
+      if (response.ok) {
+        const result = await response.json();
+        console.log('Full refresh initiated:', result);
+        
+        // Poll for updates
+        setTimeout(() => {
+          fetchCanvas();
+          fetchStats();
+        }, 5000);
+        
+        setTimeout(() => {
+          setIsUpdating(false);
+        }, 10000);
       }
     } catch (error) {
       console.error('Error refreshing canvas:', error);
-    } finally {
       setIsUpdating(false);
     }
   };
@@ -296,13 +415,41 @@ const CanvasPage = ({ user, authToken, onNavigateToChat, onSignOut }) => {
           <div className="empty-canvas">
             <FileText className="empty-canvas-icon" />
             <h2>Your Canvas is Empty</h2>
-            <p>Start chatting with your AI advisors to populate your PhD Canvas with insights and guidance!</p>
-            <button 
-              className="start-chatting-button"
-              onClick={onNavigateToChat}
-            >
-              Start Chatting
-            </button>
+            {isUpdating || isProcessingFirstTime ? (
+              <div>
+                <p>
+                  {isProcessingFirstTime 
+                    ? 'Processing your chat history to populate insights...' 
+                    : 'Updating canvas with latest insights...'
+                  }
+                </p>
+                <div className="loading-spinner">
+                  <RefreshCw className="spinning" />
+                </div>
+                <p className="processing-note">
+                  This may take a few minutes for extensive chat history.
+                </p>
+              </div>
+            ) : (
+              <div>
+                <p>Start chatting with your AI advisors to populate your PhD Canvas with insights!</p>
+                <div className="empty-canvas-actions">
+                  <button 
+                    className="start-chatting-button"
+                    onClick={onNavigateToChat}
+                  >
+                    Start Chatting
+                  </button>
+                  <button 
+                    className="refresh-button secondary"
+                    onClick={handleFullRefresh}
+                  >
+                    <RefreshCw className="action-icon" />
+                    Process Existing Chats
+                  </button>
+                </div>
+              </div>
+            )}
           </div>
         ) : (
           <div className="sections-container">

phd-advisor-frontend/src/styles/CanvasPage.css

@@ -191,10 +191,9 @@
 .empty-canvas {
   text-align: center;
   padding: 4rem 2rem;
-  background: var(--bg-primary);
-  border-radius: 16px;
-  border: 1px solid var(--border-primary);
-  box-shadow: var(--shadow-md);
+  color: var(--text-secondary);
+  max-width: 600px;
+  margin: 0 auto;
 }
 
 .empty-canvas-icon {
@@ -205,15 +204,13 @@
 }
 
 .empty-canvas h2 {
-  margin: 1rem 0;
-  font-size: 1.8rem;
+  margin-bottom: 1rem;
   color: var(--text-primary);
 }
 
 .empty-canvas p {
-  margin-bottom: 2rem;
-  color: var(--text-secondary);
-  font-size: 1.1rem;
+  margin-bottom: 1.5rem;
+  line-height: 1.6;
 }
 
 .start-chatting-button {
@@ -401,6 +398,44 @@
   color: var(--text-primary);
 }
 
+.empty-canvas-actions {
+  display: flex;
+  gap: 1rem;
+  justify-content: center;
+  align-items: center;
+  margin-top: 1.5rem;
+}
+
+.refresh-button.secondary {
+  background: var(--bg-secondary);
+  color: var(--text-secondary);
+  border: 1px solid var(--border-primary);
+}
+
+.refresh-button.secondary:hover {
+  background: var(--bg-tertiary);
+  color: var(--text-primary);
+}
+
+.loading-spinner {
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  margin: 1rem 0;
+}
+
+.loading-spinner .spinning {
+  animation: spin 2s linear infinite;
+  width: 2rem;
+  height: 2rem;
+  color: var(--accent-primary);
+}
+
+@keyframes spin {
+  from { transform: rotate(0deg); }
+  to { transform: rotate(360deg); }
+}
+
 .insight-footer {
   display: flex;
   justify-content: space-between;