@learnpack/learnpack 5.0.313 → 5.0.316

package/src/commands/serve.ts

@@ -36,6 +36,7 @@ import {
   initialContentGenerator,
   addInteractivity,
   generateCodeChallenge,
+  generateStepSlug,
 } from "../utils/rigoActions"
 import * as dotenv from "dotenv"
 
@@ -43,6 +44,7 @@ import * as dotenv from "dotenv"
 import {
   getFilenameFromUrl,
   getReadmeExtension,
+  insertStepInCorrectPosition,
 } from "../utils/creatorUtilities"
 // import { handleAssetCreation } from "./publish"
 import axios from "axios"
@@ -281,41 +283,6 @@ const createMultiLangAsset = async (
   }
 }
 
-async function startExerciseGeneration(
-  rigoToken: string,
-  steps: Lesson[],
-  packageContext: FormState,
-  exercise: Lesson,
-  courseSlug: string,
-  purposeSlug: string,
-  lastLesson = ""
-): Promise<number> {
-  const exSlug = 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 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: Lesson) => {
   return {
     ...lesson,
@@ -341,7 +308,7 @@ async function startInitialContentGeneration(
   const exSlug = 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
   emitToCourse(courseSlug, "course-creation", {
@@ -388,7 +355,7 @@ async function startInteractivityGeneration(
   const exSlug = 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
   emitToCourse(courseSlug, "course-creation", {
@@ -399,7 +366,6 @@ async function startInteractivityGeneration(
 
   const componentsYml = await fetchComponentsYml()
 
-  // Get current syllabus to include used_components
   const currentSyllabus = await getSyllabus(courseSlug, bucket)
 
   const fullSyllabus = {
@@ -424,7 +390,6 @@ async function startInteractivityGeneration(
     webhookUrl
   )
 
-  console.log("INTERACTIVITY GENERATOR RES", res)
   return res.id
 }
 
@@ -449,6 +414,14 @@ async function createInitialReadme(
   }
 }
 
+const getConfigJSON = async (bucket: Bucket, courseSlug: string) => {
+  const configFile = await bucket.file(
+    `courses/${courseSlug}/.learn/config.json`
+  )
+  const [content] = await configFile.download()
+  return JSON.parse(content.toString())
+}
+
 async function getSyllabus(
   courseSlug: string,
   bucket: Bucket
@@ -499,18 +472,18 @@ async function updateUsedComponents(
 
 async function updateLessonWithInitialContent(
   courseSlug: string,
-  lessonID: string,
+  lessonUID: string,
   initialResponse: any,
   bucket: Bucket
-): Promise<void> {
+): Promise<Lesson | null> {
   const syllabus = await getSyllabus(courseSlug, bucket)
   const lessonIndex = syllabus.lessons.findIndex(
-    lesson => lesson.id === lessonID
+    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]
@@ -519,22 +492,23 @@ async function updateLessonWithInitialContent(
   lesson.initialContent = initialResponse.lesson_content
 
   await saveSyllabus(courseSlug, syllabus, bucket)
+  return lesson
 }
 
 async function updateLessonStatusToError(
   courseSlug: string,
-  lessonID: string,
+  lessonUID: string,
   bucket: Bucket
 ): Promise<void> {
   try {
     const syllabus = await getSyllabus(courseSlug, bucket)
     const lessonIndex = syllabus.lessons.findIndex(
-      lesson => lesson.id === lessonID
+      lesson => lesson.uid === lessonUID
     )
 
     if (lessonIndex === -1) {
       console.error(
-        `Lesson ${lessonID} not found in syllabus when updating status to error`
+        `Lesson ${lessonUID} not found in syllabus when updating status to error`
       )
       return
     }
@@ -561,9 +535,9 @@ async function updateLessonStatusToError(
     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)
   }
 }
 
@@ -1096,12 +1070,18 @@ export default class ServeCommand extends SessionCommand {
     )
 
     app.post(
-      "/actions/continue-generating/:courseSlug/:lessonId",
+      "/actions/continue-generating/:courseSlug/:lessonUid",
       async (req, res) => {
-        const { courseSlug, lessonId } = req.params
+        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",
@@ -1111,10 +1091,10 @@ export default class ServeCommand extends SessionCommand {
         const syllabus = await getSyllabus(courseSlug, bucket)
 
         const exercise = syllabus.lessons.find(
-          lesson => lesson.id === lessonId
+          lesson => lesson.uid === lessonUid
         )
         const exerciseIndex = syllabus.lessons.findIndex(
-          lesson => lesson.id === lessonId
+          lesson => lesson.uid === lessonUid
         )
 
         // previous exercise
@@ -1270,276 +1250,281 @@ export default class ServeCommand extends SessionCommand {
       }
     })
 
+    // 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/exercise-processor/:lessonID/:rigoToken",
+      "/webhooks/:courseSlug/initial-content-processor/:lessonUID/:rigoToken",
       async (req, res) => {
-        // console.log("Receiving a webhook to exercise processor")
-        const { courseSlug, lessonID, rigoToken } = req.params
-        const readme = req.body
+        const { courseSlug, lessonUID, rigoToken } = req.params
+        const response = req.body
 
-        const syllabus = await bucket.file(
-          `courses/${courseSlug}/.learn/initialSyllabus.json`
-        )
-        const [content] = await syllabus.download()
-        const syllabusJson: Syllabus = JSON.parse(content.toString())
+        console.log("RECEIVING INITIAL CONTENT WEBHOOK", response)
 
-        if (readme.status === "ERROR") {
-          emitToCourse(courseSlug, "course-creation", {
-            lesson: lessonID,
-            status: "error",
-            log: `❌ Error generating the lesson ${lessonID}`,
-          })
-        }
+        const syllabus = await getSyllabus(courseSlug, bucket)
 
-        const exerciseIndex = syllabusJson.lessons.findIndex(
-          lesson => lesson.id === lessonID
+        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: Lesson | null = syllabus.lessons[exerciseIndex]
         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()}`
-          )
+        // Handle errors
+        if (response.status === "ERROR") {
+          await updateLessonStatusToError(courseSlug, lessonUID, bucket)
           emitToCourse(courseSlug, "course-creation", {
             lesson: exSlug,
-            status: "generating",
-            log: `✅ Code file created for ${exercise.title}`,
+            status: "error",
+            log: `❌ Error generating initial content for lesson ${exSlug}`,
           })
 
-          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}`
-            )
+          // Retry initial content generation
+          try {
             emitToCourse(courseSlug, "course-creation", {
               lesson: exSlug,
               status: "generating",
-              log: `✅ Solution file created for ${exercise.title}`,
+              log: `🔄 Retrying initial content generation for lesson ${exSlug}`,
             })
-          }
-        }
-
-        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/: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)
-          emitToCourse(courseSlug, "course-creation", {
-            lesson: lessonID,
-            status: "error",
-            log: `❌ Error generating initial content for lesson ${lessonID}`,
-          })
-
-          // Retry initial content generation
-          try {
-            const syllabus = await getSyllabus(courseSlug, bucket)
-            const lessonIndex = syllabus.lessons.findIndex(
-              lesson => lesson.id === lessonID
+            const retryCompletionId = await startInitialContentGeneration(
+              rigoToken,
+              syllabus.lessons,
+              syllabus.courseInfo,
+              exercise,
+              courseSlug,
+              syllabus.courseInfo.purpose,
+              ""
             )
-            const exercise = syllabus.lessons[lessonIndex]
-
-            if (exercise) {
-              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)
+            // 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
             )
             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}`,
             })
           }
 
@@ -1548,29 +1533,27 @@ export default class ServeCommand extends SessionCommand {
 
         try {
           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(
+          exercise = await updateLessonWithInitialContent(
             courseSlug,
-            lessonID,
+            lessonUID,
             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]
+          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]
@@ -1590,50 +1573,48 @@ export default class ServeCommand extends SessionCommand {
             }
           }
 
-          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)
+          const completionId = await startInteractivityGeneration(
+            rigoToken,
+            syllabus.lessons,
+            syllabus.courseInfo,
+            exercise,
+            courseSlug,
+            syllabus.courseInfo.purpose,
+            bucket,
+            lastLesson
+          )
 
-            emitToCourse(courseSlug, "course-creation", {
-              lesson: lessonID,
-              status: "generating",
-              log: `🔄 Starting interactivity phase for lesson ${exercise.title}`,
-            })
+          // 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)
 
           emitToCourse(courseSlug, "course-creation", {
-            lesson: lessonID,
+            lesson: exSlug,
+            status: "generating",
+            log: `🔄 Starting interactivity phase for lesson ${exercise.title}`,
+          })
+
+          emitToCourse(courseSlug, "course-creation", {
+            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)
           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)
@@ -1644,35 +1625,37 @@ export default class ServeCommand extends SessionCommand {
 
     // Phase 2: Interactivity generation webhook (replaces exercise-processor logic)
     app.post(
-      "/webhooks/:courseSlug/interactivity-processor/:lessonID/:rigoToken",
+      "/webhooks/:courseSlug/interactivity-processor/:lessonUID/:rigoToken",
       async (req, res) => {
-        const { courseSlug, lessonID, rigoToken } = req.params
+        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)
           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
+              lesson => lesson.uid === lessonUID
             )
             const exercise = syllabus.lessons[lessonIndex]
 
             if (exercise && exercise.initialContent) {
               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
@@ -1727,9 +1710,9 @@ export default class ServeCommand extends SessionCommand {
               retryError
             )
             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}`,
             })
           }
 
@@ -1739,11 +1722,11 @@ export default class ServeCommand extends SessionCommand {
         try {
           const syllabus = await getSyllabus(courseSlug, bucket)
           const exerciseIndex = syllabus.lessons.findIndex(
-            lesson => lesson.id === lessonID
+            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" })
           }
 
@@ -1778,49 +1761,6 @@ export default class ServeCommand extends SessionCommand {
             `${targetDir}/${readmeFilename}`
           )
 
-          // Handle code files if it's a coding exercise
-          if (
-            exercise.type.toLowerCase() === "code" &&
-            response.parsed.codefile_content
-          ) {
-            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()}`
-            )
-
-            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}`
-              )
-              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 &&
@@ -1858,11 +1798,11 @@ export default class ServeCommand extends SessionCommand {
           res.json({ status: "SUCCESS" })
         } catch (error) {
           console.error("Error processing interactivity webhook:", error)
-          await updateLessonStatusToError(courseSlug, lessonID, bucket)
+          await updateLessonStatusToError(courseSlug, lessonUID, bucket)
           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)
@@ -2082,29 +2022,98 @@ export default class ServeCommand extends SessionCommand {
         })
       }
     )
-    app.post("/exercise/:slug/create", async (req, res) => {
-      console.log("POST /exercise/:slug/create")
-      const query = req.query
-      const { title, readme, language } = req.body
+    // 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 (!title || !readme) {
-        return res
-          .status(400)
-          .json({ error: "Missing title or readme content" })
+      if (!rigoToken) {
+        return res.status(400).json({ error: "RigoToken not found" })
       }
 
-      const courseSlug = query.slug
+      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 fileName = `courses/${courseSlug}/exercises/${title}/README${getReadmeExtension(
-        language
-      )}`
-      const file = bucket.file(fileName)
-      await file.save(readme)
-      const created = await file.exists()
-      res.send({
-        message: "File updated",
-        created,
+      const stepSlugResponse = await 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: Lesson = {
+        id: stepId,
+        title: stepTitle,
+        description: description,
+        type: "READ",
+        duration: 2,
+        generated: false,
+        status: "GENERATING",
+        initialContent: "",
+        translations: {},
+        uid: stepSlug,
+      }
+
+      const newLessons = 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({ ...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) => {