context extended

maybe need polishing

apps/admin/src/app/api/fitness-goals/[id]/complete/route.ts

@@ -0,0 +1,39 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@clerk/nextjs/server';
+import { getDatabase } from '@/lib/database';
+
+// POST - Mark goal as complete
+export async function POST(
+    req: NextRequest,
+    { params }: { params: { id: string } }
+) {
+    try {
+        const { userId } = await auth();
+        if (!userId) {
+            return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+        }
+
+        const { id } = await params;
+        const db = await getDatabase();
+
+        // Verify goal exists and user owns it
+        const existingGoal = await db.getFitnessGoalById(id);
+        if (!existingGoal) {
+            return NextResponse.json({ error: 'Goal not found' }, { status: 404 });
+        }
+        if (existingGoal.userId !== userId) {
+            return NextResponse.json({ error: 'Forbidden' }, { status: 403 });
+        }
+
+        // Mark as completed
+        const completedGoal = await db.completeGoal(id);
+
+        return NextResponse.json(completedGoal);
+    } catch (error) {
+        console.error('Error completing fitness goal:', error);
+        return NextResponse.json(
+            { error: 'Internal server error' },
+            { status: 500 }
+        );
+    }
+}

apps/admin/src/app/api/fitness-goals/[id]/route.ts

@@ -0,0 +1,119 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@clerk/nextjs/server';
+import { getDatabase } from '@/lib/database';
+
+// GET - Get specific goal
+export async function GET(
+    req: NextRequest,
+    { params }: { params: { id: string } }
+) {
+    try {
+        const { userId } = await auth();
+        if (!userId) {
+            return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+        }
+
+        const { id } = await params;
+        const db = await getDatabase();
+
+        const goal = await db.getFitnessGoalById(id);
+
+        if (!goal) {
+            return NextResponse.json({ error: 'Goal not found' }, { status: 404 });
+        }
+
+        // Verify ownership
+        if (goal.userId !== userId) {
+            return NextResponse.json({ error: 'Forbidden' }, { status: 403 });
+        }
+
+        return NextResponse.json(goal);
+    } catch (error) {
+        console.error('Error fetching fitness goal:', error);
+        return NextResponse.json(
+            { error: 'Internal server error' },
+            { status: 500 }
+        );
+    }
+}
+
+// PUT - Update goal
+export async function PUT(
+    req: NextRequest,
+    { params }: { params: { id: string } }
+) {
+    try {
+        const { userId } = await auth();
+        if (!userId) {
+            return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+        }
+
+        const { id } = await params;
+        const db = await getDatabase();
+
+        // Verify goal exists and user owns it
+        const existingGoal = await db.getFitnessGoalById(id);
+        if (!existingGoal) {
+            return NextResponse.json({ error: 'Goal not found' }, { status: 404 });
+        }
+        if (existingGoal.userId !== userId) {
+            return NextResponse.json({ error: 'Forbidden' }, { status: 403 });
+        }
+
+        const updates = await req.json();
+
+        // Don't allow changing userId or id
+        delete updates.userId;
+        delete updates.id;
+        delete updates.createdAt;
+
+        const updatedGoal = await db.updateFitnessGoal(id, updates);
+
+        return NextResponse.json(updatedGoal);
+    } catch (error) {
+        console.error('Error updating fitness goal:', error);
+        return NextResponse.json(
+            { error: 'Internal server error' },
+            { status: 500 }
+        );
+    }
+}
+
+// DELETE - Delete goal
+export async function DELETE(
+    req: NextRequest,
+    { params }: { params: { id: string } }
+) {
+    try {
+        const { userId } = await auth();
+        if (!userId) {
+            return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+        }
+
+        const { id } = await params;
+        const db = await getDatabase();
+
+        // Verify goal exists and user owns it
+        const existingGoal = await db.getFitnessGoalById(id);
+        if (!existingGoal) {
+            return NextResponse.json({ error: 'Goal not found' }, { status: 404 });
+        }
+        if (existingGoal.userId !== userId) {
+            return NextResponse.json({ error: 'Forbidden' }, { status: 403 });
+        }
+
+        const deleted = await db.deleteFitnessGoal(id);
+
+        if (deleted) {
+            return NextResponse.json({ success: true });
+        } else {
+            return NextResponse.json({ error: 'Failed to delete goal' }, { status: 500 });
+        }
+    } catch (error) {
+        console.error('Error deleting fitness goal:', error);
+        return NextResponse.json(
+            { error: 'Internal server error' },
+            { status: 500 }
+        );
+    }
+}

apps/admin/src/app/api/fitness-goals/route.ts

@@ -0,0 +1,95 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { auth } from '@clerk/nextjs/server';
+import { getDatabase } from '@/lib/database';
+import { randomBytes } from 'crypto';
+
+// GET - List user's fitness goals
+export async function GET(req: NextRequest) {
+    try {
+        const { userId } = await auth();
+        if (!userId) {
+            return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+        }
+
+        const { searchParams } = new URL(req.url);
+        const targetUserId = searchParams.get('userId') || userId;
+        const status = searchParams.get('status'); // active, completed, all
+
+        const db = await getDatabase();
+
+        // Fetch goals with optional status filter
+        const goals = await db.getFitnessGoalsByUserId(
+            targetUserId,
+            status && status !== 'all' ? status : undefined
+        );
+
+        return NextResponse.json(goals);
+    } catch (error) {
+        console.error('Error fetching fitness goals:', error);
+        return NextResponse.json(
+            { error: 'Internal server error' },
+            { status: 500 }
+        );
+    }
+}
+
+// POST - Create new fitness goal
+export async function POST(req: NextRequest) {
+    try {
+        const { userId } = await auth();
+        if (!userId) {
+            return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+        }
+
+        const body = await req.json();
+        const {
+            goalType,
+            title,
+            description,
+            targetValue,
+            currentValue,
+            unit,
+            targetDate,
+            priority,
+            notes,
+            fitnessProfileId
+        } = body;
+
+        // Validation
+        if (!goalType || !title) {
+            return NextResponse.json(
+                { error: 'goalType and title are required' },
+                { status: 400 }
+            );
+        }
+
+        const db = await getDatabase();
+
+        // Create the goal
+        const goal = await db.createFitnessGoal({
+            id: randomBytes(16).toString('hex'),
+            userId,
+            fitnessProfileId: fitnessProfileId || undefined,
+            goalType,
+            title,
+            description: description || undefined,
+            targetValue: targetValue || undefined,
+            currentValue: currentValue || 0,
+            unit: unit || undefined,
+            startDate: new Date(),
+            targetDate: targetDate ? new Date(targetDate) : undefined,
+            status: 'active',
+            progress: 0,
+            priority: priority || 'medium',
+            notes: notes || undefined
+        });
+
+        return NextResponse.json(goal, { status: 201 });
+    } catch (error) {
+        console.error('Error creating fitness goal:', error);
+        return NextResponse.json(
+            { error: 'Internal server error' },
+            { status: 500 }
+        );
+    }
+}

apps/admin/src/app/api/recommendations/generate/route.ts

@@ -1,5 +1,7 @@
 import { NextResponse } from "next/server";
 import { getDatabase } from "@/lib/database";
+import { buildAIContext } from "@/lib/ai/ai-context";
+import { buildEnhancedPrompt, buildBasicPrompt } from "@/lib/ai/prompt-builder";
 
 export async function POST(req: Request) {
     try {
@@ -21,26 +23,17 @@ export async function POST(req: Request) {
             );
         }
 
-        // Construct prompt
-        const prompt = `
-      You are a professional fitness trainer and nutritionist.
-      Generate a detailed daily recommendation for a user with the following profile:
-      - Height: ${profile.height} cm
-      - Weight: ${profile.weight} kg
-      - Age: ${profile.age}
-      - Gender: ${profile.gender}
-      - Goal: ${profile.fitnessGoals.join(", ")}
-      - Activity Level: ${profile.activityLevel}
-      - Medical Conditions: ${profile.medicalConditions || "None"}
-      - Injuries: ${profile.injuries || "None"}
-
-      Please provide the response in the following JSON format ONLY, no other text. Do not use markdown formatting or code blocks:
-      {
-        "recommendationText": "General advice and motivation for today.",
-        "activityPlan": "Detailed workout or activity plan for today.",
-        "dietPlan": "Detailed meal plan for today."
-      }
-    `;
+        // Build AI context with goals and recommendations
+        let prompt: string;
+        try {
+            const context = await buildAIContext(userId);
+            prompt = buildEnhancedPrompt(context);
+            console.log('Using enhanced AI context with goals and history');
+        } catch (error) {
+            // Fallback to basic prompt if context building fails
+            console.warn('Failed to build AI context, using basic prompt:', error);
+            prompt = buildBasicPrompt(profile);
+        }
 
         let parsedResponse;