Merge remote-tracking branch 'origin/integration-branch' into github-actions

Author: lawruixi

collaboration-service/collaboration-service/env.example

@@ -10,6 +10,7 @@ GOOGLE_AI_API_KEY=your_google_ai_api_key_here
 # External Services
 QUESTION_SERVICE_BASE_URL=http://localhost:5050
 USER_SERVICE_BASE_URL=http://localhost:3001
+MATCHING_SERVICE_URL=http://localhost:4001
 
 # CORS
 CORS_ORIGIN=http://localhost:3000,http://localhost:3002,http://localhost:4000

collaboration-service/collaboration-service/src/controllers/aiController.js

@@ -93,20 +93,101 @@ export const chatWithAI = async (req, res) => {
 export const analyzeSessionCode = async (req, res) => {
   try {
     const sessionId = req.params.id;
+    console.log(`[AI Controller] analyzeSessionCode called for session ${sessionId}`);
 
     // Verify session exists
     const session = await redisRepo.getJson(`collab:session:${sessionId}`);
     if (!session) {
+      console.error(`[AI Controller] Session ${sessionId} not found in Redis`);
       return res.status(404).json({ error: "Session not found" });
     }
 
-    // Get current code
-    const doc = await redisRepo.getJson(`collab:document:${sessionId}`);
-    const code = doc?.text || req.body.code || "";
-    const language = req.body.language || "python";
+    // Get current code - try multiple sources
+    let doc = await redisRepo.getJson(`collab:document:${sessionId}`);
+    console.log(`[AI Controller] Document from Redis:`, doc ? 'exists' : 'null');
+    let code = doc?.text || req.body.code || "";
+    
+    // Get current language from request body or Redis storage
+    let language = req.body.language;
+    if (!language) {
+      // Try to get language from Redis storage
+      const langData = await redisRepo.getJson(`collab:language:${sessionId}`);
+      language = langData?.language || "python";
+      console.log(`[AI Controller] Got language from Redis storage: ${language}`);
+    } else {
+      language = language;
+    }
+
+    console.log(`[AI Controller] Code length from Redis: ${code.length}`);
+    console.log(`[AI Controller] Language for analysis: ${language}`);
+
+    // If no code from Redis, try to get from YJS in-memory storage
+    if (!code || code.trim() === "") {
+      console.log(`[AI Controller] No code in Redis, trying YJS storage...`);
+      try {
+        const { rooms } = await import("../ws/yjsGateway.js");
+        console.log(`[AI Controller] YJS rooms Map size: ${rooms.size}`);
+        console.log(`[AI Controller] Looking for room with sessionId: ${sessionId}`);
+        const room = rooms.get(sessionId);
+        
+        if (room && room.doc) {
+          console.log(`[AI Controller] Room found, getting text from YJS...`);
+          
+          // Try multiple field names (code is what CodePane uses)
+          const possibleFields = ['code', 'monaco', 'text', 'content', 'doc'];
+          let foundCode = '';
+          
+          for (const field of possibleFields) {
+            try {
+              const ytext = room.doc.getText(field);
+              const text = ytext.toString();
+              console.log(`[AI Controller] YJS field '${field}' has length: ${text.length}`);
+              if (text.trim() !== '') {
+                foundCode = text;
+                console.log(`[AI Controller] Found code in field '${field}'`);
+                break;
+              }
+            } catch (e) {
+              // Field doesn't exist, try next
+            }
+          }
+          
+          // Also try to get the document state
+          try {
+            const state = Y.encodeStateAsUpdate(room.doc);
+            console.log(`[AI Controller] YJS document state size: ${state.length} bytes`);
+            
+            // Try to get all text fields
+            console.log(`[AI Controller] Inspecting YJS document structure...`);
+          } catch (e) {
+            console.error(`[AI Controller] Error inspecting document:`, e);
+          }
+          
+          code = foundCode;
+          console.log(`[AI Controller] Final code from YJS storage (length: ${code.length})`);
+          
+          // Save it to Redis for future access
+          if (code && code.trim() !== '') {
+            console.log(`[AI Controller] Saving code to Redis...`);
+            await redisRepo.setJson(`collab:document:${sessionId}`, {
+              text: code,
+              version: Date.now()
+            });
+            console.log(`[AI Controller] Saved to Redis successfully`);
+          } else {
+            console.log(`[AI Controller] No code found in YJS document`);
+          }
+        } else {
+          console.log(`[AI Controller] No room found in YJS storage for session ${sessionId}`);
+          console.log(`[AI Controller] Available sessions in YJS:`, Array.from(rooms.keys()));
+        }
+      } catch (err) {
+        console.error("[AI Controller] Could not access YJS storage:", err);
+      }
+    }
 
-    if (!code) {
-      return res.status(400).json({ error: "No code to analyze" });
+    if (!code || code.trim() === "") {
+      return res.status(400).json({ error: "No code to analyze. Please write some code in the editor first." });
     }
 
     // Analyze code

collaboration-service/collaboration-service/src/controllers/sessionController.js

@@ -121,11 +121,36 @@ export const leaveSession = async (req, res) => {
     delete pres[userId];
     await redisRepo.setJson(`collab:presence:${s.id}`, pres);
 
+    // ✅ Remove user from participants set
+    await redisRepo.sRem(`collab:session:${s.id}:participants`, userId);
+    console.log(`[leaveSession] Removed ${userId} from participants set`);
+    
+        // ✅ Clean up matching service state
+    try {
+      const matchingServiceUrl = process.env.NEXT_PUBLIC_MATCHING_SERVICE_URL || "http://localhost:4001";
+      const response = await axios.post(`${matchingServiceUrl}/match/leave`, { userId });
+      console.log(`[leaveSession] Matching service cleanup for ${userId}:`, response.status);
+    } catch (err) {
+      console.warn(`[leaveSession] Failed to clean up matching service for ${userId}:`, err.message);
+    }
+
     let status = "active";
     if (Object.keys(pres).length === 0) {
       s.status = "ended";
       await redisRepo.setJson(`collab:session:${s.id}`, s);
       status = "ended";
+      
+      // Clean up both users from matching service when session ends completely
+      try {
+        const matchingServiceUrl = process.env.NEXT_PUBLIC_MATCHING_SERVICE_URL || "http://localhost:4001";
+        const users = [s.userA, s.userB].filter(Boolean);
+        for (const pid of users) {
+          const response = await axios.post(`${matchingServiceUrl}/match/leave`, { userId: pid });
+          console.log(`[leaveSession] Matching service cleanup for ${pid}:`, response.status);
+        }
+      } catch (err) {
+        console.warn(`[leaveSession] Failed to clean up all users from matching service:`, err.message);
+      }
     }
 
     // Broadcast session:end to all remaining participants

collaboration-service/collaboration-service/src/repos/redisRepo.js

@@ -80,4 +80,9 @@ export const redisRepo = {
     const res = await redisClient.sIsMember(key, member);
     return res === 1 || res === true;
   },
+
+  async sRem(key, ...members) {
+    // node-redis v4 expects a flat array, not nested
+    await redisClient.sRem(key, members);
+  },
 };

collaboration-service/collaboration-service/src/services/aiService.js

@@ -4,7 +4,13 @@ import dotenv from "dotenv";
 dotenv.config();
 
 // Initialize Gemini AI
-const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY || "");
+const apiKey = process.env.GOOGLE_AI_API_KEY || "";
+
+if (!apiKey) {
+  console.warn("[AI Service] Warning: GOOGLE_AI_API_KEY not found. AI features will not work.");
+}
+
+const genAI = new GoogleGenerativeAI(apiKey);
 
 // Conversation history per session (in-memory for now, can be moved to Redis later)
 const sessionConversations = new Map();
@@ -28,6 +34,11 @@ function getConversationHistory(sessionId) {
  */
 export async function generateAIResponse(sessionId, userMessage, context = {}) {
   try {
+    // Check if API key is configured
+    if (!apiKey) {
+      throw new Error("AI service is not configured. Please set GOOGLE_AI_API_KEY in your environment variables.");
+    }
+
     const model = genAI.getGenerativeModel({ model: "gemini-2.5-flash" });
 
     // Build system context
@@ -88,7 +99,17 @@ IMPORTANT GUIDELINES:
 
   } catch (error) {
     console.error("[AI Service] Error generating response:", error);
-    throw new Error("Failed to generate AI response: " + error.message);
+    
+    // Provide more helpful error messages
+    if (error.message.includes("API_KEY")) {
+      throw new Error("AI service API key is invalid. Please check your configuration.");
+    } else if (error.message.includes("quota") || error.message.includes("429")) {
+      throw new Error("AI service quota exceeded. Please try again later.");
+    } else if (error.message.includes("configuration")) {
+      throw error; // Re-throw configuration errors as-is
+    } else {
+      throw new Error("Failed to generate AI response: " + error.message);
+    }
   }
 }
 
@@ -99,11 +120,19 @@ IMPORTANT GUIDELINES:
  * @param {string} language - Programming language
  * @returns {Promise<object>} Analysis result
  */
-export async function analyzeCode(sessionId, code, language) {
+export async function analyzeCode(sessionId, code, language = "python") {
   try {
+    if (!apiKey) {
+      throw new Error("AI service is not configured");
+    }
+
     const model = genAI.getGenerativeModel({ model: "gemini-2.5-flash" });
 
-    const prompt = `Analyze the following ${language} code and provide:
+    console.log(`[AI Service] Analyzing code in language: ${language}`);
+    
+    const prompt = `You are analyzing ${language.toUpperCase()} code. The code provided is definitely ${language} code.
+
+Analyze the following ${language} code and provide:
 1. Code quality assessment (1-10)
 2. Time complexity
 3. Space complexity
@@ -146,6 +175,10 @@ Please provide your analysis in a structured, concise format.`;
  */
 export async function getHint(sessionId, question, currentCode = "") {
   try {
+    if (!apiKey) {
+      throw new Error("AI service is not configured");
+    }
+
     const model = genAI.getGenerativeModel({ model: "gemini-2.5-flash" });
 
     let prompt = `Provide a helpful hint (not the complete solution) for this coding problem:
@@ -181,6 +214,10 @@ DIFFICULTY: ${question.difficulty}
  */
 export async function debugError(sessionId, code, error, language) {
   try {
+    if (!apiKey) {
+      throw new Error("AI service is not configured");
+    }
+
     const model = genAI.getGenerativeModel({ model: "gemini-2.5-flash" });
 
     const prompt = `Help debug this ${language} code that's producing an error:
@@ -225,6 +262,10 @@ export function clearConversationHistory(sessionId) {
  */
 export async function explainConcept(concept, language = "general") {
   try {
+    if (!apiKey) {
+      throw new Error("AI service is not configured");
+    }
+
     const model = genAI.getGenerativeModel({ model: "gemini-2.5-flash" });
 
     const prompt = `Explain the concept of "${concept}" in the context of ${language} programming.

collaboration-service/collaboration-service/src/services/yjsService.js

@@ -0,0 +1,119 @@
+import * as Y from 'yjs';
+import * as awarenessProtocol from 'y-protocols/awareness';
+import { redisRepo } from '../repos/redisRepo.js';
+
+// In-memory store for Yjs documents
+const ydocs = new Map();
+
+/**
+ * Get or create a Yjs document for a session
+ */
+export function getYDoc(sessionId) {
+  if (ydocs.has(sessionId)) {
+    return ydocs.get(sessionId);
+  }
+
+  const ydoc = new Y.Doc();
+  ydoc.on('update', async (update, origin) => {
+    if (origin !== 'redis') {
+      // Save update to Redis when document changes
+      try {
+        const key = `collab:yjs:${sessionId}`;
+        await redisRepo.setJson(key, {
+          update: Array.from(update),
+          timestamp: Date.now()
+        });
+      } catch (err) {
+        console.error('[YjsService] Failed to save to Redis:', err);
+      }
+    }
+  });
+
+  ydocs.set(sessionId, ydoc);
+  return ydoc;
+}
+
+/**
+ * Load a Yjs document from Redis
+ */
+export async function loadYDocFromRedis(sessionId) {
+  const ydoc = getYDoc(sessionId);
+  
+  try {
+    const key = `collab:yjs:${sessionId}`;
+    const stored = await redisRepo.getJson(key);
+    
+    if (stored && stored.update) {
+      // Apply the stored update without triggering the update handler
+      Y.applyUpdate(ydoc, new Uint8Array(stored.update));
+    }
+  } catch (err) {
+    console.error('[YjsService] Failed to load from Redis:', err);
+  }
+  
+  return ydoc;
+}
+
+/**
+ * Handle a Yjs update from a client
+ */
+export async function applyYjsUpdate(sessionId, update, userId) {
+  const ydoc = getYDoc(sessionId);
+  
+  try {
+    // Apply the update
+    Y.applyUpdate(ydoc, new Uint8Array(update), 'client');
+    
+    // Get the text content from the document (using 'monaco' key to match frontend)
+    const ytext = ydoc.getText('monaco');
+    const text = ytext.toString();
+    
+    // Also save to old Redis key for backward compatibility with test execution
+    try {
+      await redisRepo.setJson(`collab:document:${sessionId}`, {
+        text: text,
+        version: Date.now() // Use timestamp as version
+      });
+      console.log(`[YjsService] Saved text to collab:document:${sessionId}`);
+    } catch (err) {
+      console.error('[YjsService] Failed to save to old key:', err);
+    }
+    
+    return {
+      success: true,
+      text,
+      version: ydoc.transactionOrigin
+    };
+  } catch (err) {
+    console.error('[YjsService] Failed to apply update:', err);
+    return {
+      success: false,
+      error: err.message
+    };
+  }
+}
+
+/**
+ * Create an awareness instance for a session
+ */
+const awarenessInstances = new Map();
+
+export function getAwareness(sessionId) {
+  if (awarenessInstances.has(sessionId)) {
+    return awarenessInstances.get(sessionId);
+  }
+  
+  const ydoc = getYDoc(sessionId);
+  const awareness = new awarenessProtocol.Awareness(ydoc);
+  awarenessInstances.set(sessionId, awareness);
+  
+  return awareness;
+}
+
+/**
+ * Clean up resources for a session
+ */
+export function cleanupSession(sessionId) {
+  ydocs.delete(sessionId);
+  awarenessInstances.delete(sessionId);
+}