File changes

Author: base44-builder[bot]

functions/aiMentorMatcher.ts

@@ -8,60 +8,48 @@ Deno.serve(async (req) => {
     if (!user) {
       return Response.json({ error: 'Unauthorized' }, { status: 401 });
     }
-
-    const { user_email, skills_to_learn } = await req.json();
-    const targetEmail = user_email || user.email;
-
-    // Get user's profile
-    const userProfile = await base44.entities.UserProfile.filter({ 
-      user_email: targetEmail 
-    });
-
-    if (!userProfile[0]) {
-      return Response.json({ error: 'User profile not found' }, { status: 404 });
+    
+    const { menteeEmail } = await req.json();
+    
+    // Fetch mentee profile
+    const [menteeProfile] = await base44.entities.UserProfile.filter({ user_email: menteeEmail });
+    
+    if (!menteeProfile) {
+      return Response.json({ error: 'Mentee profile not found' }, { status: 404 });
     }
-
-    // Get all potential mentors (users with expertise)
-    const allProfiles = await base44.asServiceRole.entities.UserProfile.filter({
-      user_email: { $ne: targetEmail }
-    });
-
+    
+    // Fetch all potential mentors (experienced users)
+    const allProfiles = await base44.asServiceRole.entities.UserProfile.filter({});
     const potentialMentors = allProfiles.filter(p => 
-      p.expertise_areas && p.expertise_areas.length > 0
+      p.user_email !== menteeEmail &&
+      (p.skills?.length || 0) >= 5 &&
+      new Date(p.start_date) < new Date(menteeProfile.start_date)
     );
+    
+    // Use AI to analyze best matches
+    const analysisPrompt = `Analyze mentor-mentee compatibility for employee onboarding:
 
-    // Use AI to match mentors
-    const matches = await base44.integrations.Core.InvokeLLM({
-      prompt: `Match this user with the best internal mentors:
-
-USER SEEKING MENTORSHIP:
-Email: ${targetEmail}
-Department: ${userProfile[0].department || 'N/A'}
-Job Title: ${userProfile[0].job_title || 'N/A'}
-Current Skills: ${userProfile[0].skill_levels?.map(s => `${s.skill} (${s.level})`).join(', ') || 'None'}
-Skills to Learn: ${skills_to_learn?.join(', ') || userProfile[0].skill_interests?.join(', ') || 'General growth'}
-Learning Goals: ${userProfile[0].learning_goals?.join(', ') || 'N/A'}
+Mentee Profile:
+- Email: ${menteeEmail}
+- Role: ${menteeProfile.role || 'Not specified'}
+- Department: ${menteeProfile.department || 'Not specified'}
+- Skills: ${menteeProfile.skills?.map(s => s.skill_name).join(', ') || 'None listed'}
+- Interests: ${menteeProfile.interests?.join(', ') || 'None listed'}
+- Career aspirations: ${menteeProfile.career_aspirations || 'Not specified'}
 
-POTENTIAL MENTORS (${potentialMentors.length} available):
-${potentialMentors.slice(0, 20).map(p => `
-- ${p.user_email}
-  Department: ${p.department || 'N/A'}
-  Job Title: ${p.job_title || 'N/A'}
-  Expertise: ${p.expertise_areas?.join(', ') || 'None'}
-  Skills: ${p.skill_levels?.map(s => `${s.skill} (${s.level})`).join(', ') || 'None'}
+Potential Mentors (${potentialMentors.length}):
+${potentialMentors.slice(0, 10).map((p, i) => `
+${i + 1}. ${p.user_email}
+   Role: ${p.role || 'Unknown'}
+   Department: ${p.department || 'Unknown'}
+   Skills: ${p.skills?.map(s => s.skill_name).join(', ') || 'None'}
+   Experience: ${p.career_history?.length || 0} positions
 `).join('\n')}
 
-Find the top 5 best mentor matches considering:
-1. Expertise alignment with learning goals
-2. Department/role relevance
-3. Skill level compatibility (mentor should be advanced in areas user wants to learn)
-
-For each match provide:
-- mentor_email
-- match_score (0-100)
-- matching_skills (array of overlapping skills)
-- mentorship_areas (what they can teach)
-- reasoning (why this is a good match)`,
+Return the top 3 mentor matches with scores and reasoning.`;
+    
+    const matches = await base44.integrations.Core.InvokeLLM({
+      prompt: analysisPrompt,
       response_json_schema: {
         type: "object",
         properties: {
@@ -72,24 +60,47 @@ For each match provide:
               properties: {
                 mentor_email: { type: "string" },
                 match_score: { type: "number" },
-                matching_skills: { type: "array", items: { type: "string" } },
-                mentorship_areas: { type: "array", items: { type: "string" } },
-                reasoning: { type: "string" }
+                skill_overlap_score: { type: "number" },
+                department_alignment: { type: "boolean" },
+                reasoning: { type: "string" },
+                suggested_goals: {
+                  type: "array",
+                  items: { type: "string" }
+                }
               }
             }
           }
         }
       }
     });
-
+    
+    // Save top matches to database
+    for (const match of matches.matches.slice(0, 3)) {
+      const existing = await base44.entities.MentorMatch.filter({
+        mentor_email: match.mentor_email,
+        mentee_email: menteeEmail
+      });
+      
+      if (existing.length === 0) {
+        await base44.asServiceRole.entities.MentorMatch.create({
+          mentor_email: match.mentor_email,
+          mentee_email: menteeEmail,
+          match_score: match.match_score,
+          matching_criteria: {
+            skill_overlap: match.skill_overlap_score,
+            department_alignment: match.department_alignment
+          },
+          status: 'suggested',
+          goals: match.suggested_goals?.map(g => ({ goal: g, progress: 0 })) || []
+        });
+      }
+    }
+    
     return Response.json({
       success: true,
-      user_email: targetEmail,
       matches: matches.matches
     });
-
   } catch (error) {
-    console.error('Mentor matching error:', error);
     return Response.json({ error: error.message }, { status: 500 });
   }
 });

functions/proactiveOnboardingTips.ts

@@ -0,0 +1,95 @@
+import { createClientFromRequest } from 'npm:@base44/[email protected]';
+
+Deno.serve(async (req) => {
+  try {
+    const base44 = createClientFromRequest(req);
+    const user = await base44.auth.me();
+    
+    if (!user) {
+      return Response.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+    
+    const { userEmail } = await req.json();
+    
+    // Fetch user activity data
+    const [profile] = await base44.entities.UserProfile.filter({ user_email: userEmail });
+    const [userPoints] = await base44.entities.UserPoints.filter({ user_email: userEmail });
+    const participations = await base44.entities.Participation.filter({ user_email: userEmail });
+    const recognitions = await base44.entities.Recognition.filter({ sender_email: userEmail });
+    const teamMemberships = await base44.entities.TeamMembership.filter({ user_email: userEmail });
+    
+    // Calculate time since registration
+    const accountAge = profile?.created_date ? 
+      Math.floor((Date.now() - new Date(profile.created_date).getTime()) / (1000 * 60 * 60 * 24)) : 0;
+    
+    // Build activity summary
+    const activitySummary = {
+      accountAgeDays: accountAge,
+      profileComplete: !!(profile?.role && profile?.department && profile?.bio),
+      hasProfilePicture: !!profile?.profile_picture_url,
+      skillsCount: profile?.skills?.length || 0,
+      eventsAttended: participations.filter(p => p.status === 'attended').length,
+      eventsRegistered: participations.length,
+      recognitionsSent: recognitions.length,
+      teamsJoined: teamMemberships.length,
+      totalPoints: userPoints?.total_points || 0,
+      currentLevel: userPoints?.current_level || 1
+    };
+    
+    // AI generates proactive tips
+    const tipsPrompt = `Generate 3 personalized onboarding tips for a new employee:
+
+User Activity:
+- Account age: ${activitySummary.accountAgeDays} days
+- Profile complete: ${activitySummary.profileComplete ? 'Yes' : 'No'}
+- Profile picture: ${activitySummary.hasProfilePicture ? 'Yes' : 'No'}
+- Skills listed: ${activitySummary.skillsCount}
+- Events registered: ${activitySummary.eventsRegistered}
+- Events attended: ${activitySummary.eventsAttended}
+- Recognitions sent: ${activitySummary.recognitionsSent}
+- Teams joined: ${activitySummary.teamsJoined}
+- Total points: ${activitySummary.totalPoints}
+- Level: ${activitySummary.currentLevel}
+
+Based on their activity, suggest:
+1. Next best action to take
+2. Missing opportunity they should explore
+3. Motivational tip or milestone celebration
+
+Make tips friendly, specific, and actionable.`;
+    
+    const tips = await base44.integrations.Core.InvokeLLM({
+      prompt: tipsPrompt,
+      response_json_schema: {
+        type: "object",
+        properties: {
+          tips: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                title: { type: "string" },
+                message: { type: "string" },
+                action: { type: "string" },
+                action_url: { type: "string" },
+                icon: { type: "string" }
+              }
+            }
+          },
+          priority_action: { type: "string" },
+          motivation_message: { type: "string" }
+        }
+      }
+    });
+    
+    return Response.json({
+      success: true,
+      activitySummary,
+      tips: tips.tips,
+      priorityAction: tips.priority_action,
+      motivationMessage: tips.motivation_message
+    });
+  } catch (error) {
+    return Response.json({ error: error.message }, { status: 500 });
+  }
+});

functions/wellnessEngagementCorrelation.ts

@@ -0,0 +1,129 @@
+import { createClientFromRequest } from 'npm:@base44/[email protected]';
+
+Deno.serve(async (req) => {
+  try {
+    const base44 = createClientFromRequest(req);
+    const user = await base44.auth.me();
+    
+    if (!user || user.role !== 'admin') {
+      return Response.json({ error: 'Unauthorized' }, { status: 403 });
+    }
+    
+    const { lookbackDays = 30 } = await req.json();
+    
+    // Fetch wellness and engagement data
+    const wellnessLogs = await base44.asServiceRole.entities.WellnessLog.filter({});
+    const participations = await base44.asServiceRole.entities.Participation.filter({});
+    const recognitions = await base44.asServiceRole.entities.Recognition.filter({});
+    const userPoints = await base44.asServiceRole.entities.UserPoints.filter({});
+    
+    // Group by user
+    const userWellnessActivity = wellnessLogs.reduce((acc, log) => {
+      if (!acc[log.user_email]) {
+        acc[log.user_email] = { logs: 0, totalValue: 0 };
+      }
+      acc[log.user_email].logs += 1;
+      acc[log.user_email].totalValue += log.value;
+      return acc;
+    }, {});
+    
+    const userEngagement = participations.reduce((acc, p) => {
+      if (!acc[p.user_email]) {
+        acc[p.user_email] = { events: 0 };
+      }
+      acc[p.user_email].events += 1;
+      return acc;
+    }, {});
+    
+    recognitions.forEach(r => {
+      if (!userEngagement[r.sender_email]) {
+        userEngagement[r.sender_email] = { events: 0, recognitions: 0 };
+      }
+      userEngagement[r.sender_email].recognitions = (userEngagement[r.sender_email].recognitions || 0) + 1;
+    });
+    
+    // Build correlation dataset
+    const correlationData = Object.keys(userWellnessActivity).map(email => ({
+      email,
+      wellnessLogs: userWellnessActivity[email].logs,
+      wellnessTotal: userWellnessActivity[email].totalValue,
+      eventsAttended: userEngagement[email]?.events || 0,
+      recognitionsSent: userEngagement[email]?.recognitions || 0,
+      totalPoints: userPoints.find(p => p.user_email === email)?.total_points || 0
+    }));
+    
+    // AI analysis
+    const analysisPrompt = `Analyze correlation between wellness activity and employee engagement:
+
+Dataset (${correlationData.length} employees):
+${correlationData.slice(0, 10).map(d => `
+- Email: ${d.email}
+  Wellness logs: ${d.wellnessLogs}
+  Wellness total: ${d.wellnessTotal}
+  Events attended: ${d.eventsAttended}
+  Recognitions sent: ${d.recognitionsSent}
+  Total points: ${d.totalPoints}
+`).join('\n')}
+
+Analyze:
+1. Correlation strength between wellness activity and engagement
+2. Key patterns and insights
+3. Recommendations for HR to improve both wellness and engagement
+4. Suggested wellness challenge goals based on engagement data`;
+    
+    const analysis = await base44.integrations.Core.InvokeLLM({
+      prompt: analysisPrompt,
+      response_json_schema: {
+        type: "object",
+        properties: {
+          correlation_strength: {
+            type: "string",
+            enum: ["strong_positive", "moderate_positive", "weak", "no_correlation"]
+          },
+          correlation_score: { type: "number" },
+          key_insights: {
+            type: "array",
+            items: { type: "string" }
+          },
+          patterns: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                pattern: { type: "string" },
+                impact: { type: "string" }
+              }
+            }
+          },
+          recommendations: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                action: { type: "string" },
+                expected_outcome: { type: "string" },
+                priority: { type: "string" }
+              }
+            }
+          },
+          suggested_challenge_goals: {
+            type: "object",
+            properties: {
+              steps_daily: { type: "number" },
+              meditation_minutes: { type: "number" },
+              hydration_glasses: { type: "number" }
+            }
+          }
+        }
+      }
+    });
+    
+    return Response.json({
+      success: true,
+      analysis,
+      sampleSize: correlationData.length
+    });
+  } catch (error) {
+    return Response.json({ error: error.message }, { status: 500 });
+  }
+});