@learnpack/learnpack 5.0.293 → 5.0.295

package/lib/commands/serve.js

@@ -625,6 +625,79 @@ class ServeCommand extends SessionCommand_1.default {
                 res.status(500).json({ error: error.message });
             }
         });
+        app.post("/webhooks/:courseSlug/:exercisePosition/process-coding-challege/", async (req, res) => {
+            const { courseSlug, exercisePosition } = req.params;
+            const body = req.body;
+            console.log("RECEIVING CODING CHALLENGE WEBHOOK for course:", courseSlug, "exercise position:", exercisePosition);
+            console.log("Webhook body:", JSON.stringify(body, null, 2));
+            try {
+                if (body.status === "ERROR") {
+                    console.error("❌ Error in coding challenge generation:", body.error);
+                    return res.json({ status: "ERROR" });
+                }
+                // Parse the RigoBot response
+                if (body.parsed) {
+                    const { files, reasoning } = body.parsed;
+                    console.log("📋 Reasoning:", reasoning);
+                    console.log("📁 Files received:", files);
+                    if (files && Array.isArray(files)) {
+                        console.log("✅ Processing files for coding challenge...");
+                        // Get the current exercise info to determine the exercise directory
+                        const syllabus = await getSyllabus(courseSlug, bucket);
+                        const exercise = syllabus.lessons[parseInt(exercisePosition)];
+                        if (!exercise) {
+                            console.error(`❌ Exercise not found at position ${exercisePosition}`);
+                            return res.status(404).json({ error: "Exercise not found" });
+                        }
+                        const exSlug = (0, creatorUtilities_2.slugify)(exercise.id + "-" + exercise.title);
+                        const exerciseDir = `courses/${courseSlug}/exercises/${exSlug}`;
+                        for (const fileStr of files) {
+                            try {
+                                const fileObj = JSON.parse(fileStr);
+                                console.log(`📄 Processing file: ${fileObj.name}`);
+                                // Save the main file with content
+                                if (fileObj.name && fileObj.content) {
+                                    const filePath = `${exerciseDir}/${fileObj.name}`;
+                                    // eslint-disable-next-line no-await-in-loop
+                                    await uploadFileToBucket(bucket, fileObj.content, filePath);
+                                    console.log(`✅ Saved file: ${filePath}`);
+                                }
+                                // Save the solution file if it exists
+                                if (fileObj.name && fileObj.solution) {
+                                    const nameParts = fileObj.name.split(".");
+                                    if (nameParts.length > 1) {
+                                        const extension = nameParts.pop();
+                                        const baseName = nameParts.join(".");
+                                        const solutionFileName = `${baseName}.solution.hide.${extension}`;
+                                        const solutionFilePath = `${exerciseDir}/${solutionFileName}`;
+                                        // eslint-disable-next-line no-await-in-loop
+                                        await uploadFileToBucket(bucket, fileObj.solution, solutionFilePath);
+                                        console.log(`✅ Saved solution file: ${solutionFilePath}`);
+                                    }
+                                    else {
+                                        // If no extension, just add .solution.hide
+                                        const solutionFileName = `${fileObj.name}.solution.hide`;
+                                        const solutionFilePath = `${exerciseDir}/${solutionFileName}`;
+                                        // eslint-disable-next-line no-await-in-loop
+                                        await uploadFileToBucket(bucket, fileObj.solution, solutionFilePath);
+                                        console.log(`✅ Saved solution file: ${solutionFilePath}`);
+                                    }
+                                }
+                            }
+                            catch (parseError) {
+                                console.error(`❌ Error parsing file:`, parseError);
+                            }
+                        }
+                        console.log("✅ All coding challenge files saved successfully");
+                    }
+                }
+                res.json({ status: "SUCCESS" });
+            }
+            catch (error) {
+                console.error("❌ Error processing coding challenge webhook:", error);
+                res.status(500).json({ error: error.message });
+            }
+        });
         app.post("/actions/continue-generating/:courseSlug/:position", async (req, res) => {
             const { courseSlug, position } = req.params;
             const { feedback, mode } = req.body;
@@ -695,6 +768,65 @@ class ServeCommand extends SessionCommand_1.default {
             await (0, exports.processImage)(image.url, image.alt, rigoToken, courseSlug);
             res.json({ status: "QUEUED" });
         });
+        app.post("/actions/generate-code-challenge", async (req, res) => {
+            const rigoToken = req.header("x-rigo-token");
+            const { code_challenge, lesson_content, exercise_position, course_slug } = req.body;
+            if (!rigoToken) {
+                return res.status(400).json({
+                    error: "Rigo token is required. x-rigo-token header is missing",
+                });
+            }
+            if (!code_challenge) {
+                return res.status(400).json({
+                    error: "code_challenge is required",
+                });
+            }
+            if (!lesson_content) {
+                return res.status(400).json({
+                    error: "lesson_content is required",
+                });
+            }
+            if (!course_slug) {
+                return res.status(400).json({
+                    error: "course_slug is required",
+                });
+            }
+            if (exercise_position === undefined || exercise_position === null) {
+                return res.status(400).json({
+                    error: "exercise_position is required",
+                });
+            }
+            if (typeof exercise_position !== "number" || exercise_position < 0) {
+                return res.status(400).json({
+                    error: "exercise_position must be a valid number >= 0",
+                });
+            }
+            try {
+                const webhookUrl = `${process.env.HOST}/webhooks/${course_slug}/${exercise_position}/process-coding-challege/`;
+                const result = await (0, rigoActions_1.generateCodeChallenge)(rigoToken, {
+                    lesson_content,
+                    challenge_proposal: code_challenge,
+                }, webhookUrl);
+                if (!result) {
+                    return res.status(500).json({
+                        error: "Failed to generate code challenge",
+                    });
+                }
+                console.log("Code challenge generation started:", result);
+                res.json({
+                    status: "QUEUED",
+                    id: result.id,
+                    message: "Code challenge generation started",
+                });
+            }
+            catch (error) {
+                console.error("Error generating code challenge:", error);
+                res.status(500).json({
+                    error: "Failed to start code challenge generation",
+                    details: error.message,
+                });
+            }
+        });
         app.post("/webhooks/:courseSlug/exercise-processor/:lessonID/:rigoToken", async (req, res) => {
             // console.log("Receiving a webhook to exercise processor")
             const { courseSlug, lessonID, rigoToken } = req.params;