@learnpack/learnpack 5.0.313 → 5.0.316

package/lib/commands/serve.js

@@ -165,29 +165,13 @@ const createMultiLangAsset = async (bucket, rigoToken, bcToken, courseSlug, cour
         all_translations.push(asset.slug);
     }
 };
-async function startExerciseGeneration(rigoToken, steps, packageContext, exercise, courseSlug, purposeSlug, lastLesson = "") {
-    const exSlug = (0, creatorUtilities_2.slugify)(exercise.id + "-" + exercise.title);
-    console.log("Starting generation of", exSlug);
-    const webhookUrl = `${process.env.HOST}/webhooks/${courseSlug}/exercise-processor/${exercise.id}/${rigoToken}`;
-    const res = await (0, rigoActions_1.readmeCreator)(rigoToken.trim(), {
-        title: `${exercise.id} - ${exercise.title}`,
-        output_lang: packageContext.language || "en",
-        list_of_exercises: JSON.stringify(steps.map(step => step.id + "-" + step.title)),
-        tutorial_description: JSON.stringify(cleanFormState(packageContext)),
-        lesson_description: exercise.description,
-        kind: exercise.type.toLowerCase(),
-        last_lesson: lastLesson,
-    }, purposeSlug, webhookUrl);
-    console.log("README CREATOR RES", res);
-    return res.id;
-}
 const lessonCleaner = (lesson) => {
     return Object.assign(Object.assign({}, lesson), { duration: undefined, generated: undefined, status: undefined, translations: undefined, uid: undefined, initialContent: undefined, locked: undefined });
 };
 async function startInitialContentGeneration(rigoToken, steps, packageContext, exercise, courseSlug, purposeSlug, lastLesson = "") {
     const exSlug = (0, creatorUtilities_2.slugify)(exercise.id + "-" + exercise.title);
     console.log("Starting initial content generation for", exSlug);
-    const webhookUrl = `${process.env.HOST}/webhooks/${courseSlug}/initial-content-processor/${exercise.id}/${rigoToken}`;
+    const webhookUrl = `${process.env.HOST}/webhooks/${courseSlug}/initial-content-processor/${exercise.uid}/${rigoToken}`;
     // Emit notification that initial content generation is starting
     (0, creatorSocket_1.emitToCourse)(courseSlug, "course-creation", {
         lesson: exSlug,
@@ -213,7 +197,7 @@ async function startInitialContentGeneration(rigoToken, steps, packageContext, e
 async function startInteractivityGeneration(rigoToken, steps, packageContext, exercise, courseSlug, purposeSlug, bucket, lastLesson = "") {
     const exSlug = (0, creatorUtilities_2.slugify)(exercise.id + "-" + exercise.title);
     console.log("Starting interactivity generation for", exSlug);
-    const webhookUrl = `${process.env.HOST}/webhooks/${courseSlug}/interactivity-processor/${exercise.id}/${rigoToken}`;
+    const webhookUrl = `${process.env.HOST}/webhooks/${courseSlug}/interactivity-processor/${exercise.uid}/${rigoToken}`;
     // Emit notification that interactivity generation is starting
     (0, creatorSocket_1.emitToCourse)(courseSlug, "course-creation", {
         lesson: exSlug,
@@ -221,7 +205,6 @@ async function startInteractivityGeneration(rigoToken, steps, packageContext, ex
         log: `🔄 Starting interactivity generation for lesson: ${exercise.title}`,
     });
     const componentsYml = await fetchComponentsYml();
-    // Get current syllabus to include used_components
     const currentSyllabus = await getSyllabus(courseSlug, bucket);
     const fullSyllabus = {
         steps: steps.map(lessonCleaner),
@@ -238,7 +221,6 @@ async function startInteractivityGeneration(rigoToken, steps, packageContext, ex
         output_language: packageContext.language || "en",
         current_syllabus: JSON.stringify(fullSyllabus),
     }, webhookUrl);
-    console.log("INTERACTIVITY GENERATOR RES", res);
     return res.id;
 }
 async function createInitialReadme(tutorialInfo, tutorialSlug, rigoToken) {
@@ -254,6 +236,11 @@ async function createInitialReadme(tutorialInfo, tutorialSlug, rigoToken) {
         console.error("Error creating initial readme", error);
     }
 }
+const getConfigJSON = async (bucket, courseSlug) => {
+    const configFile = await bucket.file(`courses/${courseSlug}/.learn/config.json`);
+    const [content] = await configFile.download();
+    return JSON.parse(content.toString());
+};
 async function getSyllabus(courseSlug, bucket) {
     const syllabus = await bucket.file(`courses/${courseSlug}/.learn/initialSyllabus.json`);
     const [content] = await syllabus.download();
@@ -280,24 +267,25 @@ async function updateUsedComponents(courseSlug, usedComponents, bucket) {
     console.log("Updated component usage:", syllabus.used_components);
     await saveSyllabus(courseSlug, syllabus, bucket);
 }
-async function updateLessonWithInitialContent(courseSlug, lessonID, initialResponse, bucket) {
+async function updateLessonWithInitialContent(courseSlug, lessonUID, initialResponse, bucket) {
     const syllabus = await getSyllabus(courseSlug, bucket);
-    const lessonIndex = syllabus.lessons.findIndex(lesson => lesson.id === lessonID);
+    const lessonIndex = syllabus.lessons.findIndex(lesson => lesson.uid === lessonUID);
     if (lessonIndex === -1) {
-        console.error(`Lesson ${lessonID} not found in syllabus`);
-        return;
+        console.error(`Lesson ${lessonUID} not found in syllabus`);
+        return null;
     }
     const lesson = syllabus.lessons[lessonIndex];
     // Update initial content
     lesson.initialContent = initialResponse.lesson_content;
     await saveSyllabus(courseSlug, syllabus, bucket);
+    return lesson;
 }
-async function updateLessonStatusToError(courseSlug, lessonID, bucket) {
+async function updateLessonStatusToError(courseSlug, lessonUID, bucket) {
     try {
         const syllabus = await getSyllabus(courseSlug, bucket);
-        const lessonIndex = syllabus.lessons.findIndex(lesson => lesson.id === lessonID);
+        const lessonIndex = syllabus.lessons.findIndex(lesson => lesson.uid === lessonUID);
         if (lessonIndex === -1) {
-            console.error(`Lesson ${lessonID} not found in syllabus when updating status to error`);
+            console.error(`Lesson ${lessonUID} not found in syllabus when updating status to error`);
             return;
         }
         const lesson = syllabus.lessons[lessonIndex];
@@ -318,10 +306,10 @@ async function updateLessonStatusToError(courseSlug, lessonID, bucket) {
         }
         lesson.translations = currentTranslations;
         await saveSyllabus(courseSlug, syllabus, bucket);
-        console.log(`Updated lesson ${lessonID} status to ERROR in syllabus`);
+        console.log(`Updated lesson ${lessonUID} status to ERROR in syllabus`);
     }
     catch (error) {
-        console.error(`Error updating lesson ${lessonID} status to ERROR:`, error);
+        console.error(`Error updating lesson ${lessonUID} status to ERROR:`, error);
     }
 }
 async function continueWithNextLesson(courseSlug, currentExerciseIndex, rigoToken, finalContent, bucket) {
@@ -689,18 +677,23 @@ class ServeCommand extends SessionCommand_1.default {
                 res.status(500).json({ error: error.message });
             }
         });
-        app.post("/actions/continue-generating/:courseSlug/:lessonId", async (req, res) => {
-            const { courseSlug, lessonId } = req.params;
+        app.post("/actions/continue-generating/:courseSlug/:lessonUid", async (req, res) => {
+            const { courseSlug, lessonUid } = req.params;
             const { feedback, mode } = req.body;
             const rigoToken = req.header("x-rigo-token");
+            console.log("CONTINUE GENERATING REQUEST RECEIVED");
+            // console.log("COURSE SLUG", courseSlug);
+            console.log("LESSON UID", lessonUid);
+            // console.log("FEEDBACK", feedback);
+            // console.log("MODE", mode);
             if (!rigoToken) {
                 return res.status(400).json({
                     error: "Rigo token is required. x-rigo-token header is missing",
                 });
             }
             const syllabus = await getSyllabus(courseSlug, bucket);
-            const exercise = syllabus.lessons.find(lesson => lesson.id === lessonId);
-            const exerciseIndex = syllabus.lessons.findIndex(lesson => lesson.id === lessonId);
+            const exercise = syllabus.lessons.find(lesson => lesson.uid === lessonUid);
+            const exerciseIndex = syllabus.lessons.findIndex(lesson => lesson.uid === lessonUid);
             // previous exercise
             let previousReadme = "---";
             const previousExercise = syllabus.lessons[exerciseIndex - 1];
@@ -819,189 +812,255 @@ class ServeCommand extends SessionCommand_1.default {
                 });
             }
         });
-        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;
-            const readme = req.body;
-            const syllabus = await bucket.file(`courses/${courseSlug}/.learn/initialSyllabus.json`);
-            const [content] = await syllabus.download();
-            const syllabusJson = JSON.parse(content.toString());
-            if (readme.status === "ERROR") {
-                (0, creatorSocket_1.emitToCourse)(courseSlug, "course-creation", {
-                    lesson: lessonID,
-                    status: "error",
-                    log: `❌ Error generating the lesson ${lessonID}`,
-                });
-            }
-            const exerciseIndex = syllabusJson.lessons.findIndex(lesson => lesson.id === lessonID);
+        // 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
+        //     const readme = req.body
+        //     const syllabus = await bucket.file(
+        //       `courses/${courseSlug}/.learn/initialSyllabus.json`
+        //     )
+        //     const [content] = await syllabus.download()
+        //     const syllabusJson: Syllabus = JSON.parse(content.toString())
+        //     if (readme.status === "ERROR") {
+        //       emitToCourse(courseSlug, "course-creation", {
+        //         lesson: lessonID,
+        //         status: "error",
+        //         log: `❌ Error generating the lesson ${lessonID}`,
+        //       })
+        //     }
+        //     const exerciseIndex = syllabusJson.lessons.findIndex(
+        //       lesson => lesson.id === lessonID
+        //     )
+        //     if (exerciseIndex === -1) {
+        //       console.log(
+        //         "Exercise not found receiving webhook, this should not happen",
+        //         lessonID
+        //       )
+        //       return res.json({ status: "ERROR", error: "Exercise not found" })
+        //     }
+        //     const exercise = syllabusJson.lessons[exerciseIndex]
+        //     if (!exercise) {
+        //       return res.json({
+        //         status: "ERROR",
+        //         error: "Exercise not found or is invalid",
+        //       })
+        //     }
+        //     const nextExercise = syllabusJson.lessons[exerciseIndex + 1] || null
+        //     const exSlug = slugify(exercise.id + "-" + exercise.title)
+        //     const readability = checkReadability(
+        //       readme.parsed.content,
+        //       PARAMS.max_words,
+        //       3
+        //     )
+        //     emitToCourse(courseSlug, "course-creation", {
+        //       lesson: exSlug,
+        //       status: "generating",
+        //       log: `🔄 The lesson ${exercise.title} has a readability score of ${readability.fkglResult.fkgl}`,
+        //     })
+        //     const exercisesDir = `courses/${courseSlug}/exercises`
+        //     const targetDir = `${exercisesDir}/${exSlug}`
+        //     const readmeFilename = `README${getReadmeExtension(
+        //       readme.parsed.language_code
+        //     )}`
+        //     await uploadFileToBucket(
+        //       bucket,
+        //       readability.newMarkdown,
+        //       `${targetDir}/${readmeFilename}`
+        //     )
+        //     if (
+        //       exercise.type.toLowerCase() === "code" &&
+        //       readme.parsed.codefile_content
+        //     ) {
+        //       emitToCourse(courseSlug, "course-creation", {
+        //         lesson: exSlug,
+        //         status: "generating",
+        //         log: `🔄 Creating code file for ${exercise.title}`,
+        //       })
+        //       await uploadFileToBucket(
+        //         bucket,
+        //         readme.parsed.codefile_content,
+        //         `${targetDir}/${readme.parsed.codefile_name.toLowerCase().trim()}`
+        //       )
+        //       emitToCourse(courseSlug, "course-creation", {
+        //         lesson: exSlug,
+        //         status: "generating",
+        //         log: `✅ Code file created for ${exercise.title}`,
+        //       })
+        //       if (readme.parsed.solution_content) {
+        //         const codeFileName = readme.parsed.codefile_name
+        //           .toLowerCase()
+        //           .trim()
+        //         const solutionFileName = "solution.hide." + codeFileName
+        //         await uploadFileToBucket(
+        //           bucket,
+        //           readme.parsed.solution_content,
+        //           `${targetDir}/${solutionFileName}`
+        //         )
+        //         emitToCourse(courseSlug, "course-creation", {
+        //           lesson: exSlug,
+        //           status: "generating",
+        //           log: `✅ Solution file created for ${exercise.title}`,
+        //         })
+        //       }
+        //     }
+        //     let nextCompletionId: number | null = null
+        //     if (
+        //       nextExercise &&
+        //       (exerciseIndex === 0 ||
+        //         !(exerciseIndex % 3 === 0) ||
+        //         syllabusJson.generationMode === "continue-with-all")
+        //     ) {
+        //       let feedback = ""
+        //       if (syllabusJson.feedback) {
+        //         feedback = `\n\nThe user added the following feedback with relation to the previous generations: ${syllabusJson.feedback}`
+        //       }
+        //       nextCompletionId = await startExerciseGeneration(
+        //         rigoToken,
+        //         syllabusJson.lessons,
+        //         syllabusJson.courseInfo,
+        //         nextExercise,
+        //         courseSlug,
+        //         syllabusJson.courseInfo.purpose,
+        //         readme.parsed.content + "\n\n" + feedback
+        //       )
+        //     } else {
+        //       console.log(
+        //         "Stopping generation process at",
+        //         exerciseIndex,
+        //         exercise.title,
+        //         "because it's a multiple of 3"
+        //       )
+        //     }
+        //     const newSyllabus = {
+        //       ...syllabusJson,
+        //       lessons: syllabusJson.lessons.map((lesson, index) => {
+        //         if (index === exerciseIndex) {
+        //           const currentTranslations = lesson.translations || {}
+        //           let currentTranslation =
+        //             currentTranslations[syllabusJson.courseInfo.language || "en"]
+        //           if (currentTranslation) {
+        //             currentTranslation.completedAt = Date.now()
+        //           } else {
+        //             currentTranslation = {
+        //               completionId: readme.id,
+        //               startedAt: Date.now(),
+        //               completedAt: Date.now(),
+        //             }
+        //           }
+        //           currentTranslations[syllabusJson.courseInfo.language || "en"] =
+        //             currentTranslation
+        //           return {
+        //             ...lesson,
+        //             generated: true,
+        //             status: "DONE",
+        //             translations: {
+        //               [syllabusJson.courseInfo.language || "en"]: {
+        //                 completionId: nextCompletionId,
+        //                 completedAt: Date.now(),
+        //               },
+        //             },
+        //           }
+        //         }
+        //         if (
+        //           nextExercise &&
+        //           nextExercise.id === lesson.id &&
+        //           nextCompletionId
+        //         ) {
+        //           return {
+        //             ...lesson,
+        //             generated: false,
+        //             status: "GENERATING",
+        //             translations: {
+        //               [syllabusJson.courseInfo.language || "en"]: {
+        //                 completionId: nextCompletionId,
+        //                 startedAt: Date.now(),
+        //               },
+        //             },
+        //           }
+        //         }
+        //         return { ...lesson }
+        //       }),
+        //     }
+        //     console.log("New syllabus", newSyllabus)
+        //     await uploadFileToBucket(
+        //       bucket,
+        //       JSON.stringify(newSyllabus),
+        //       `courses/${courseSlug}/.learn/initialSyllabus.json`
+        //     )
+        //     emitToCourse(courseSlug, "course-creation", {
+        //       lesson: exSlug,
+        //       status: "done",
+        //       log: `✅ The lesson ${exercise.id} - ${exercise.title} has been generated successfully!`,
+        //     })
+        //     res.json({ status: "SUCCESS" })
+        //   }
+        // )
+        // Phase 1: Initial content generation webhook
+        app.post("/webhooks/:courseSlug/initial-content-processor/:lessonUID/:rigoToken", async (req, res) => {
+            const { courseSlug, lessonUID, rigoToken } = req.params;
+            const response = req.body;
+            console.log("RECEIVING INITIAL CONTENT WEBHOOK", response);
+            const syllabus = await getSyllabus(courseSlug, bucket);
+            const exerciseIndex = syllabus.lessons.findIndex(lesson => lesson.uid === lessonUID);
             if (exerciseIndex === -1) {
-                console.log("Exercise not found receiving webhook, this should not happen", lessonID);
+                console.error("Exercise not found receiving webhook:", lessonUID);
                 return res.json({ status: "ERROR", error: "Exercise not found" });
             }
-            const exercise = syllabusJson.lessons[exerciseIndex];
-            if (!exercise) {
-                return res.json({
-                    status: "ERROR",
-                    error: "Exercise not found or is invalid",
-                });
-            }
-            const nextExercise = syllabusJson.lessons[exerciseIndex + 1] || null;
+            let exercise = syllabus.lessons[exerciseIndex];
             const exSlug = (0, creatorUtilities_2.slugify)(exercise.id + "-" + exercise.title);
-            const readability = (0, creatorUtilities_2.checkReadability)(readme.parsed.content, PARAMS.max_words, 3);
-            (0, creatorSocket_1.emitToCourse)(courseSlug, "course-creation", {
-                lesson: exSlug,
-                status: "generating",
-                log: `🔄 The lesson ${exercise.title} has a readability score of ${readability.fkglResult.fkgl}`,
-            });
-            const exercisesDir = `courses/${courseSlug}/exercises`;
-            const targetDir = `${exercisesDir}/${exSlug}`;
-            const readmeFilename = `README${(0, creatorUtilities_1.getReadmeExtension)(readme.parsed.language_code)}`;
-            await uploadFileToBucket(bucket, readability.newMarkdown, `${targetDir}/${readmeFilename}`);
-            if (exercise.type.toLowerCase() === "code" &&
-                readme.parsed.codefile_content) {
-                (0, creatorSocket_1.emitToCourse)(courseSlug, "course-creation", {
-                    lesson: exSlug,
-                    status: "generating",
-                    log: `🔄 Creating code file for ${exercise.title}`,
-                });
-                await uploadFileToBucket(bucket, readme.parsed.codefile_content, `${targetDir}/${readme.parsed.codefile_name.toLowerCase().trim()}`);
-                (0, creatorSocket_1.emitToCourse)(courseSlug, "course-creation", {
-                    lesson: exSlug,
-                    status: "generating",
-                    log: `✅ Code file created for ${exercise.title}`,
-                });
-                if (readme.parsed.solution_content) {
-                    const codeFileName = readme.parsed.codefile_name
-                        .toLowerCase()
-                        .trim();
-                    const solutionFileName = "solution.hide." + codeFileName;
-                    await uploadFileToBucket(bucket, readme.parsed.solution_content, `${targetDir}/${solutionFileName}`);
-                    (0, creatorSocket_1.emitToCourse)(courseSlug, "course-creation", {
-                        lesson: exSlug,
-                        status: "generating",
-                        log: `✅ Solution file created for ${exercise.title}`,
-                    });
-                }
-            }
-            let nextCompletionId = null;
-            if (nextExercise &&
-                (exerciseIndex === 0 ||
-                    !(exerciseIndex % 3 === 0) ||
-                    syllabusJson.generationMode === "continue-with-all")) {
-                let feedback = "";
-                if (syllabusJson.feedback) {
-                    feedback = `\n\nThe user added the following feedback with relation to the previous generations: ${syllabusJson.feedback}`;
-                }
-                nextCompletionId = await startExerciseGeneration(rigoToken, syllabusJson.lessons, syllabusJson.courseInfo, nextExercise, courseSlug, syllabusJson.courseInfo.purpose, readme.parsed.content + "\n\n" + feedback);
-            }
-            else {
-                console.log("Stopping generation process at", exerciseIndex, exercise.title, "because it's a multiple of 3");
-            }
-            const newSyllabus = Object.assign(Object.assign({}, syllabusJson), { lessons: syllabusJson.lessons.map((lesson, index) => {
-                    if (index === exerciseIndex) {
-                        const currentTranslations = lesson.translations || {};
-                        let currentTranslation = currentTranslations[syllabusJson.courseInfo.language || "en"];
-                        if (currentTranslation) {
-                            currentTranslation.completedAt = Date.now();
-                        }
-                        else {
-                            currentTranslation = {
-                                completionId: readme.id,
-                                startedAt: Date.now(),
-                                completedAt: Date.now(),
-                            };
-                        }
-                        currentTranslations[syllabusJson.courseInfo.language || "en"] =
-                            currentTranslation;
-                        return Object.assign(Object.assign({}, lesson), { generated: true, status: "DONE", translations: {
-                                [syllabusJson.courseInfo.language || "en"]: {
-                                    completionId: nextCompletionId,
-                                    completedAt: Date.now(),
-                                },
-                            } });
-                    }
-                    if (nextExercise &&
-                        nextExercise.id === lesson.id &&
-                        nextCompletionId) {
-                        return Object.assign(Object.assign({}, lesson), { generated: false, status: "GENERATING", translations: {
-                                [syllabusJson.courseInfo.language || "en"]: {
-                                    completionId: nextCompletionId,
-                                    startedAt: Date.now(),
-                                },
-                            } });
-                    }
-                    return Object.assign({}, lesson);
-                }) });
-            console.log("New syllabus", newSyllabus);
-            await uploadFileToBucket(bucket, JSON.stringify(newSyllabus), `courses/${courseSlug}/.learn/initialSyllabus.json`);
-            (0, creatorSocket_1.emitToCourse)(courseSlug, "course-creation", {
-                lesson: exSlug,
-                status: "done",
-                log: `✅ The lesson ${exercise.id} - ${exercise.title} has been generated successfully!`,
-            });
-            res.json({ status: "SUCCESS" });
-        });
-        // Phase 1: Initial content generation webhook
-        app.post("/webhooks/:courseSlug/initial-content-processor/:lessonID/:rigoToken", async (req, res) => {
-            const { courseSlug, lessonID, rigoToken } = req.params;
-            const response = req.body;
-            console.log("RECEIVING INITIAL CONTENT WEBHOOK", response);
             // Handle errors
             if (response.status === "ERROR") {
-                await updateLessonStatusToError(courseSlug, lessonID, bucket);
+                await updateLessonStatusToError(courseSlug, lessonUID, bucket);
                 (0, creatorSocket_1.emitToCourse)(courseSlug, "course-creation", {
-                    lesson: lessonID,
+                    lesson: exSlug,
                     status: "error",
-                    log: `❌ Error generating initial content for lesson ${lessonID}`,
+                    log: `❌ Error generating initial content for lesson ${exSlug}`,
                 });
                 // Retry initial content generation
                 try {
-                    const syllabus = await getSyllabus(courseSlug, bucket);
-                    const lessonIndex = syllabus.lessons.findIndex(lesson => lesson.id === lessonID);
-                    const exercise = syllabus.lessons[lessonIndex];
-                    if (exercise) {
-                        (0, creatorSocket_1.emitToCourse)(courseSlug, "course-creation", {
-                            lesson: lessonID,
-                            status: "generating",
-                            log: `🔄 Retrying initial content generation for lesson ${lessonID}`,
-                        });
-                        const retryCompletionId = await startInitialContentGeneration(rigoToken, syllabus.lessons, syllabus.courseInfo, exercise, courseSlug, syllabus.courseInfo.purpose, "");
-                        // Update lesson status to show it's retrying
-                        exercise.status = "GENERATING";
-                        exercise.translations = {
-                            [syllabus.courseInfo.language || "en"]: {
-                                completionId: retryCompletionId,
-                                startedAt: Date.now(),
-                                completedAt: 0,
-                            },
-                        };
-                        await saveSyllabus(courseSlug, syllabus, bucket);
-                    }
+                    (0, creatorSocket_1.emitToCourse)(courseSlug, "course-creation", {
+                        lesson: exSlug,
+                        status: "generating",
+                        log: `🔄 Retrying initial content generation for lesson ${exSlug}`,
+                    });
+                    const retryCompletionId = await startInitialContentGeneration(rigoToken, syllabus.lessons, syllabus.courseInfo, exercise, courseSlug, syllabus.courseInfo.purpose, "");
+                    // Update lesson status to show it's retrying
+                    exercise.status = "GENERATING";
+                    exercise.translations = {
+                        [syllabus.courseInfo.language || "en"]: {
+                            completionId: retryCompletionId,
+                            startedAt: Date.now(),
+                            completedAt: 0,
+                        },
+                    };
+                    await saveSyllabus(courseSlug, syllabus, bucket);
                 }
                 catch (retryError) {
                     console.error("Error retrying initial content generation:", retryError);
                     (0, creatorSocket_1.emitToCourse)(courseSlug, "course-creation", {
-                        lesson: lessonID,
+                        lesson: lessonUID,
                         status: "error",
-                        log: `❌ Failed to retry initial content generation for lesson ${lessonID}`,
+                        log: `❌ Failed to retry initial content generation for lesson ${lessonUID}`,
                     });
                 }
                 return res.json({ status: "ERROR" });
             }
             try {
                 (0, creatorSocket_1.emitToCourse)(courseSlug, "course-creation", {
-                    lesson: lessonID,
+                    lesson: exSlug,
                     status: "generating",
-                    log: `✅ Initial content generated for lesson ${lessonID}`,
+                    log: `✅ Initial content generated for lesson ${exSlug}`,
                 });
                 // Update lesson with initial content
-                await updateLessonWithInitialContent(courseSlug, lessonID, response.parsed, bucket);
-                // Start Phase 2: Add interactivity
-                const syllabus = await getSyllabus(courseSlug, bucket);
-                const lessonIndex = syllabus.lessons.findIndex(lesson => lesson.id === lessonID);
-                const exercise = syllabus.lessons[lessonIndex];
+                exercise = await updateLessonWithInitialContent(courseSlug, lessonUID, response.parsed, bucket);
+                if (!exercise) {
+                    console.error("Exercise not found after updating initial content");
+                    return res.json({ status: "ERROR", error: "Exercise not found" });
+                }
                 let lastLesson = "";
-                const prevLessonIndex = lessonIndex - 1;
+                const prevLessonIndex = exerciseIndex - 1;
                 if (prevLessonIndex >= 0) {
                     try {
                         const prevLesson = syllabus.lessons[prevLessonIndex];
@@ -1015,38 +1074,36 @@ class ServeCommand extends SessionCommand_1.default {
                         console.error("Error searching previous lesson content:", error);
                     }
                 }
-                if (exercise) {
-                    const completionId = await startInteractivityGeneration(rigoToken, syllabus.lessons, syllabus.courseInfo, exercise, courseSlug, syllabus.courseInfo.purpose, bucket, lastLesson);
-                    // Update lesson status to show it's in Phase 2
-                    exercise.status = "GENERATING";
-                    exercise.translations = {
-                        [syllabus.courseInfo.language || "en"]: {
-                            completionId,
-                            startedAt: Date.now(),
-                            completedAt: 0,
-                        },
-                    };
-                    await saveSyllabus(courseSlug, syllabus, bucket);
-                    (0, creatorSocket_1.emitToCourse)(courseSlug, "course-creation", {
-                        lesson: lessonID,
-                        status: "generating",
-                        log: `🔄 Starting interactivity phase for lesson ${exercise.title}`,
-                    });
-                }
+                const completionId = await startInteractivityGeneration(rigoToken, syllabus.lessons, syllabus.courseInfo, exercise, courseSlug, syllabus.courseInfo.purpose, bucket, lastLesson);
+                // Update lesson status to show it's in Phase 2
+                exercise.status = "GENERATING";
+                exercise.translations = {
+                    [syllabus.courseInfo.language || "en"]: {
+                        completionId,
+                        startedAt: Date.now(),
+                        completedAt: 0,
+                    },
+                };
+                await saveSyllabus(courseSlug, syllabus, bucket);
+                (0, creatorSocket_1.emitToCourse)(courseSlug, "course-creation", {
+                    lesson: exSlug,
+                    status: "generating",
+                    log: `🔄 Starting interactivity phase for lesson ${exercise.title}`,
+                });
                 (0, creatorSocket_1.emitToCourse)(courseSlug, "course-creation", {
-                    lesson: lessonID,
+                    lesson: exSlug,
                     status: "initial-content-complete",
-                    log: `✅ Initial content generated for lesson ${lessonID}, starting interactivity phase`,
+                    log: `✅ Initial content generated for lesson ${exSlug}, starting interactivity phase`,
                 });
                 res.json({ status: "SUCCESS" });
             }
             catch (error) {
                 console.error("Error processing initial content webhook:", error);
-                await updateLessonStatusToError(courseSlug, lessonID, bucket);
+                await updateLessonStatusToError(courseSlug, lessonUID, bucket);
                 (0, creatorSocket_1.emitToCourse)(courseSlug, "course-creation", {
-                    lesson: lessonID,
+                    lesson: exSlug,
                     status: "error",
-                    log: `❌ Error processing initial content for lesson ${lessonID}`,
+                    log: `❌ Error processing initial content for lesson ${exSlug}`,
                 });
                 res
                     .status(500)
@@ -1054,28 +1111,30 @@ class ServeCommand extends SessionCommand_1.default {
             }
         });
         // Phase 2: Interactivity generation webhook (replaces exercise-processor logic)
-        app.post("/webhooks/:courseSlug/interactivity-processor/:lessonID/:rigoToken", async (req, res) => {
-            const { courseSlug, lessonID, rigoToken } = req.params;
+        app.post("/webhooks/:courseSlug/interactivity-processor/:lessonUID/:rigoToken", async (req, res) => {
+            const { courseSlug, lessonUID, rigoToken } = req.params;
             const response = req.body;
-            console.log("RECEIVING INTERACTIVITY WEBHOOK", response);
+            console.log("RECEIVING INTERACTIVITY WEBHOOK");
+            // console.log("LESSON UID", lessonUID)
+            // console.log("RESPONSE", response)
             // Handle errors
             if (response.status === "ERROR") {
-                await updateLessonStatusToError(courseSlug, lessonID, bucket);
+                await updateLessonStatusToError(courseSlug, lessonUID, bucket);
                 (0, creatorSocket_1.emitToCourse)(courseSlug, "course-creation", {
-                    lesson: lessonID,
+                    lesson: lessonUID,
                     status: "error",
-                    log: `❌ Error adding interactivity to lesson ${lessonID}`,
+                    log: `❌ Error adding interactivity to lesson ${lessonUID}`,
                 });
                 // Retry interactivity generation
                 try {
                     const syllabus = await getSyllabus(courseSlug, bucket);
-                    const lessonIndex = syllabus.lessons.findIndex(lesson => lesson.id === lessonID);
+                    const lessonIndex = syllabus.lessons.findIndex(lesson => lesson.uid === lessonUID);
                     const exercise = syllabus.lessons[lessonIndex];
                     if (exercise && exercise.initialContent) {
                         (0, creatorSocket_1.emitToCourse)(courseSlug, "course-creation", {
-                            lesson: lessonID,
+                            lesson: lessonUID,
                             status: "generating",
-                            log: `🔄 Retrying interactivity generation for lesson ${lessonID}`,
+                            log: `🔄 Retrying interactivity generation for lesson ${lessonUID}`,
                         });
                         // Get previous lesson content for context
                         let lastLesson = "";
@@ -1108,18 +1167,18 @@ class ServeCommand extends SessionCommand_1.default {
                 catch (retryError) {
                     console.error("Error retrying interactivity generation:", retryError);
                     (0, creatorSocket_1.emitToCourse)(courseSlug, "course-creation", {
-                        lesson: lessonID,
+                        lesson: lessonUID,
                         status: "error",
-                        log: `❌ Failed to retry interactivity generation for lesson ${lessonID}`,
+                        log: `❌ Failed to retry interactivity generation for lesson ${lessonUID}`,
                     });
                 }
                 return res.json({ status: "ERROR" });
             }
             try {
                 const syllabus = await getSyllabus(courseSlug, bucket);
-                const exerciseIndex = syllabus.lessons.findIndex(lesson => lesson.id === lessonID);
+                const exerciseIndex = syllabus.lessons.findIndex(lesson => lesson.uid === lessonUID);
                 if (exerciseIndex === -1) {
-                    console.error("Exercise not found receiving webhook:", lessonID);
+                    console.error("Exercise not found receiving webhook:", lessonUID);
                     return res.json({ status: "ERROR", error: "Exercise not found" });
                 }
                 const exercise = syllabus.lessons[exerciseIndex];
@@ -1138,35 +1197,6 @@ class ServeCommand extends SessionCommand_1.default {
                     syllabus.courseInfo.language ||
                     "en")}`;
                 await uploadFileToBucket(bucket, readability.newMarkdown, `${targetDir}/${readmeFilename}`);
-                // Handle code files if it's a coding exercise
-                if (exercise.type.toLowerCase() === "code" &&
-                    response.parsed.codefile_content) {
-                    (0, creatorSocket_1.emitToCourse)(courseSlug, "course-creation", {
-                        lesson: exSlug,
-                        status: "generating",
-                        log: `🔄 Creating code file for ${exercise.title}`,
-                    });
-                    await uploadFileToBucket(bucket, response.parsed.codefile_content, `${targetDir}/${response.parsed.codefile_name
-                        .toLowerCase()
-                        .trim()}`);
-                    (0, creatorSocket_1.emitToCourse)(courseSlug, "course-creation", {
-                        lesson: exSlug,
-                        status: "generating",
-                        log: `✅ Code file created for ${exercise.title}`,
-                    });
-                    if (response.parsed.solution_content) {
-                        const codeFileName = response.parsed.codefile_name
-                            .toLowerCase()
-                            .trim();
-                        const solutionFileName = "solution.hide." + codeFileName;
-                        await uploadFileToBucket(bucket, response.parsed.solution_content, `${targetDir}/${solutionFileName}`);
-                        (0, creatorSocket_1.emitToCourse)(courseSlug, "course-creation", {
-                            lesson: exSlug,
-                            status: "generating",
-                            log: `✅ Solution file created for ${exercise.title}`,
-                        });
-                    }
-                }
                 // Update used components if provided by the AI
                 if (response.parsed.used_components &&
                     Array.isArray(response.parsed.used_components)) {
@@ -1188,11 +1218,11 @@ class ServeCommand extends SessionCommand_1.default {
             }
             catch (error) {
                 console.error("Error processing interactivity webhook:", error);
-                await updateLessonStatusToError(courseSlug, lessonID, bucket);
+                await updateLessonStatusToError(courseSlug, lessonUID, bucket);
                 (0, creatorSocket_1.emitToCourse)(courseSlug, "course-creation", {
-                    lesson: lessonID,
+                    lesson: lessonUID,
                     status: "error",
-                    log: `❌ Error processing interactivity for lesson ${lessonID}`,
+                    log: `❌ Error processing interactivity for lesson ${lessonUID}`,
                 });
                 res
                     .status(500)
@@ -1350,24 +1380,61 @@ class ServeCommand extends SessionCommand_1.default {
                 created,
             });
         });
-        app.post("/exercise/:slug/create", async (req, res) => {
-            console.log("POST /exercise/:slug/create");
-            const query = req.query;
-            const { title, readme, language } = req.body;
-            if (!title || !readme) {
-                return res
-                    .status(400)
-                    .json({ error: "Missing title or readme content" });
+        // Create a new step for a course
+        app.post("/course/:slug/create-step", async (req, res) => {
+            console.log("POST /course/:slug/create-step");
+            const params = req.params;
+            const rigoToken = req.header("x-rigo-token");
+            if (!rigoToken) {
+                return res.status(400).json({ error: "RigoToken not found" });
             }
-            const courseSlug = query.slug;
-            const fileName = `courses/${courseSlug}/exercises/${title}/README${(0, creatorUtilities_1.getReadmeExtension)(language)}`;
-            const file = bucket.file(fileName);
-            await file.save(readme);
-            const created = await file.exists();
-            res.send({
-                message: "File updated",
-                created,
+            const { description, stepIndex } = req.body;
+            if (!description) {
+                return res.status(400).json({ error: "Missing description" });
+            }
+            const courseSlug = params.slug;
+            const config = await getConfigJSON(bucket, courseSlug);
+            const initialSyllabus = await getSyllabus(courseSlug, bucket);
+            const stepSlugResponse = await (0, rigoActions_1.generateStepSlug)(rigoToken, {
+                description,
+                stepIndex,
+                courseInfo: JSON.stringify(config),
+                lang: initialSyllabus.courseInfo.language || "en",
             });
+            if (stepSlugResponse.status !== "SUCCESS") {
+                return res.status(400).json({ error: stepSlugResponse.status_text });
+            }
+            console.log("STEP SLUG GENERATED BY RIGO", stepSlugResponse);
+            const stepSlug = stepSlugResponse.parsed.slug;
+            // split the slug at the first -
+            const stepId = stepSlug.split("-")[0].trim();
+            const stepTitle = stepSlug.replace(`${stepId}-`, "").trim();
+            const newLesson = {
+                id: stepId,
+                title: stepTitle,
+                description: description,
+                type: "READ",
+                duration: 2,
+                generated: false,
+                status: "GENERATING",
+                initialContent: "",
+                translations: {},
+                uid: stepSlug,
+            };
+            const newLessons = (0, creatorUtilities_1.insertStepInCorrectPosition)(initialSyllabus.lessons, newLesson);
+            // Use new two-phase generation workflow
+            const completionId = await startInitialContentGeneration(rigoToken, newLessons, initialSyllabus.courseInfo, newLesson, courseSlug, initialSyllabus.courseInfo.purpose, "lastResult");
+            newLesson.translations = {
+                [initialSyllabus.courseInfo.language || "en"]: {
+                    completionId,
+                    startedAt: Date.now(),
+                    completedAt: 0,
+                },
+            };
+            await uploadFileToBucket(bucket, JSON.stringify(Object.assign(Object.assign({}, initialSyllabus), { lessons: newLessons })), `courses/${courseSlug}/.learn/initialSyllabus.json`);
+            const targetDir = `courses/${courseSlug}/exercises/${stepSlug}`;
+            await uploadInitialReadme(bucket, stepSlug, targetDir, initialSyllabus.courseInfo);
+            res.json({ status: "SUCCESS", message: "Exercise generati on started!" });
         });
         app.put("/actions/rename", async (req, res) => {
             console.log("PUT /actions/rename");