@learnpack/learnpack 5.0.322 → 5.0.323

package/lib/commands/serve.js

@@ -187,18 +187,32 @@ async function startInitialContentGeneration(rigoToken, steps, packageContext, e
     if (!exercise) {
         throw new errorHandler_1.ValidationError("Exercise is required but was not provided");
     }
+    console.log("EXERCISE", exercise);
     if (!exercise.id || !exercise.title) {
         throw new errorHandler_1.ValidationError(`Exercise is missing required properties: id=${exercise.id}, title=${exercise.title}`);
     }
     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.uid}/${rigoToken}`;
-    // Determine if this is the first lesson
     const exerciseIndex = steps.findIndex(lesson => lesson.uid === exercise.uid);
     const isFirstLesson = exerciseIndex === 0;
-    const endpointSlug = isFirstLesson ?
-        "initial-step-content-generator" :
-        "generate-step-initial-content";
+    const isLastLesson = exerciseIndex === steps.length - 1;
+    let endpointSlug;
+    let passTopicDescription = false;
+    if (isFirstLesson) {
+        endpointSlug = "generate-learnpack-intro-content";
+    }
+    else if (isLastLesson) {
+        endpointSlug = "generate-learnpack-outro-content";
+    }
+    else if (exercise.id.endsWith(".0")) {
+        passTopicDescription = true;
+        endpointSlug = "generate-learnpack-topic-intro-content";
+    }
+    else {
+        passTopicDescription = true;
+        endpointSlug = "generate-learnpack-subtopic-content";
+    }
     // Emit notification that initial content generation is starting
     (0, creatorSocket_1.emitToCourse)(courseSlug, "course-creation", {
         lesson: exSlug,
@@ -212,12 +226,16 @@ async function startInitialContentGeneration(rigoToken, steps, packageContext, e
     // Add random 6-digit number to avoid cache issues
     // eslint-disable-next-line no-mixed-operators
     const randomCacheEvict = Math.floor(100000 + Math.random() * 900000);
-    const res = await (0, rigoActions_1.initialContentGenerator)(rigoToken.trim(), {
-        // prev_lesson: lastLesson,
+    const inputs = {
         output_language: packageContext.language || "en",
         current_syllabus: JSON.stringify(fullSyllabus),
         lesson_description: JSON.stringify(lessonCleaner(exercise)) + `-${randomCacheEvict}`,
-    }, webhookUrl, endpointSlug);
+        target_word_count: String(PARAMS.max_words),
+        topic_description: passTopicDescription ?
+            String(exercise.description) :
+            undefined,
+    };
+    const res = await (0, rigoActions_1.initialContentGenerator)(rigoToken.trim(), inputs, webhookUrl, endpointSlug);
     console.log("INITIAL CONTENT GENERATOR RES", res);
     return res.id;
 }
@@ -1272,6 +1290,12 @@ class ServeCommand extends SessionCommand_1.default {
             console.log("RECEIVING TRANSLATION WEBHOOK", body);
             const readmePath = `courses/${courseSlug}/exercises/${exSlug}/README${(0, creatorUtilities_1.getReadmeExtension)(body.parsed.output_language_code)}`;
             await uploadFileToBucket(bucket, body.parsed.translation, readmePath);
+            (0, creatorSocket_1.emitToCourse)(courseSlug, "translation-completed", {
+                exercise: exSlug,
+                language: body.parsed.output_language_code,
+                status: "completed",
+                message: `Translation completed for ${exSlug} to ${body.parsed.output_language_code}`,
+            });
             res.json({ status: "SUCCESS" });
         });
         app.get("/check-preview-image/:slug", async (req, res) => {
@@ -1513,35 +1537,40 @@ class ServeCommand extends SessionCommand_1.default {
             }
             res.send({ message: "Files renamed" });
         });
-        app.post("/actions/translate", express.json(), async (req, res) => {
-            console.log("POST /actions/translate");
-            const { exerciseSlugs, languages, rigoToken, currentLanguage } = req.body;
-            const query = req.query;
-            const courseSlug = query.slug;
-            if (!rigoToken) {
-                return res.status(400).json({ error: "RigoToken not found" });
-            }
-            const languagesToTranslate = languages.split(",");
-            const languageCodesRes = await (0, rigoActions_1.getLanguageCodes)(rigoToken, {
-                raw_languages: languagesToTranslate.join(","),
-            });
-            const languageCodes = languageCodesRes.parsed.language_codes;
+        async function processTranslationsAsync(courseSlug, exerciseSlugs, languageCodes, rigoToken, currentLanguage, bucket) {
             try {
+                (0, creatorSocket_1.emitToCourse)(courseSlug, "translation-started", {
+                    languages: languageCodes,
+                    exercises: exerciseSlugs,
+                    status: "started",
+                    message: "Translation process started",
+                });
                 await Promise.all(exerciseSlugs.map(async (slug) => {
                     const readmePath = `courses/${courseSlug}/exercises/${slug}/README${(0, creatorUtilities_1.getReadmeExtension)(currentLanguage)}`;
                     const readme = await bucket.file(readmePath).download();
                     await Promise.all(languageCodes.map(async (language) => {
-                        // verify if the translation already exists
                         const translationPath = `courses/${courseSlug}/exercises/${slug}/README${(0, creatorUtilities_1.getReadmeExtension)(language)}`;
                         const [exists] = await bucket.file(translationPath).exists();
                         if (exists) {
                             console.log(`Translation in ${language} already exists for exercise ${slug}`);
+                            (0, creatorSocket_1.emitToCourse)(courseSlug, "translation-progress", {
+                                exercise: slug,
+                                language: language,
+                                status: "skipped",
+                                message: `Translation in ${language} already exists`,
+                            });
                             return;
                         }
                         await (0, rigoActions_1.translateExercise)(rigoToken, {
                             text_to_translate: readme.toString(),
                             output_language: language,
                         }, `${process.env.HOST}/webhooks/${courseSlug}/${slug}/save-translation`);
+                        (0, creatorSocket_1.emitToCourse)(courseSlug, "translation-progress", {
+                            exercise: slug,
+                            language: language,
+                            status: "initiated",
+                            message: `Translation job initiated for ${slug} to ${language}`,
+                        });
                     }));
                 }));
                 const course = await bucket
@@ -1571,7 +1600,6 @@ class ServeCommand extends SessionCommand_1.default {
                     await uploadFileToBucket(bucket, JSON.stringify(courseJson), `courses/${courseSlug}/learn.json`);
                     currentLanguages = Object.keys(courseJson.title);
                 }
-                // Check that all the READMEs exists
                 const missingReadmeTranslations = [];
                 let firstAvailable = "";
                 for (const languageCode of currentLanguages) {
@@ -1595,7 +1623,49 @@ class ServeCommand extends SessionCommand_1.default {
                         output_language: languageCode,
                     }, `${process.env.HOST}/webhooks/${courseSlug}/initial-readme-processor`);
                 }));
-                return res.status(200).json({ message: "Translated exercises" });
+                (0, creatorSocket_1.emitToCourse)(courseSlug, "translation-initiated", {
+                    status: "completed",
+                    message: "All translation jobs have been initiated",
+                    languages: languageCodes,
+                    exercises: exerciseSlugs,
+                });
+            }
+            catch (error) {
+                console.error("Error processing translations:", error);
+                (0, creatorSocket_1.emitToCourse)(courseSlug, "translation-error", {
+                    status: "error",
+                    error: error.message,
+                    message: "Error occurred during translation processing",
+                });
+                throw error;
+            }
+        }
+        app.post("/actions/translate", express.json(), async (req, res) => {
+            console.log("POST /actions/translate");
+            const { exerciseSlugs, languages, rigoToken, currentLanguage } = req.body;
+            const query = req.query;
+            const courseSlug = typeof query.slug === "string" ? query.slug : undefined;
+            if (!rigoToken) {
+                return res.status(400).json({ error: "RigoToken not found" });
+            }
+            if (!courseSlug) {
+                return res.status(400).json({ error: "Course slug not found" });
+            }
+            const languagesToTranslate = languages.split(",");
+            try {
+                const languageCodesRes = await (0, rigoActions_1.getLanguageCodes)(rigoToken, {
+                    raw_languages: languagesToTranslate.join(","),
+                });
+                const languageCodes = languageCodesRes.parsed.language_codes;
+                res.status(200).json({
+                    message: "Translation started",
+                    languages: languageCodes,
+                    exercises: exerciseSlugs,
+                    status: "processing",
+                });
+                processTranslationsAsync(courseSlug, exerciseSlugs, languageCodes, rigoToken, currentLanguage, bucket).catch(error => {
+                    console.error("Error in background translation processing:", error);
+                });
             }
             catch (error) {
                 console.log(error, "ERROR");

package/lib/utils/rigoActions.d.ts

@@ -95,6 +95,8 @@ type TInitialContentGeneratorInputs = {
     output_language: string;
     current_syllabus: string;
     lesson_description: string;
+    target_word_count: string;
+    topic_description?: string;
 };
 export declare const initialContentGenerator: (token: string, inputs: TInitialContentGeneratorInputs, webhookUrl?: string, endpointSlug?: string) => Promise<any>;
 type TAddInteractivityInputs = {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@learnpack/learnpack",
   "description": "Seamlessly build, sell and/or take interactive & auto-graded tutorials, start learning now or build a new tutorial to your audience.",
-  "version": "5.0.322",
+  "version": "5.0.323",
   "author": "Alejandro Sanchez @alesanchezr",
   "contributors": [
     {

package/src/commands/serve.ts

@@ -340,6 +340,8 @@ async function startInitialContentGeneration(
     throw new ValidationError("Exercise is required but was not provided")
   }
 
+  console.log("EXERCISE", exercise)
+
   if (!exercise.id || !exercise.title) {
     throw new ValidationError(
       `Exercise is missing required properties: id=${exercise.id}, title=${exercise.title}`
@@ -351,14 +353,26 @@ async function startInitialContentGeneration(
 
   const webhookUrl = `${process.env.HOST}/webhooks/${courseSlug}/initial-content-processor/${exercise.uid}/${rigoToken}`
 
-  // Determine if this is the first lesson
   const exerciseIndex = steps.findIndex(
     lesson => lesson.uid === exercise.uid
   )
   const isFirstLesson = exerciseIndex === 0
-  const endpointSlug = isFirstLesson ?
-    "initial-step-content-generator" :
-    "generate-step-initial-content"
+  const isLastLesson = exerciseIndex === steps.length - 1
+
+  let endpointSlug: string
+
+  let passTopicDescription = false
+  if (isFirstLesson) {
+    endpointSlug = "generate-learnpack-intro-content"
+  } else if (isLastLesson) {
+    endpointSlug = "generate-learnpack-outro-content"
+  } else if (exercise.id.endsWith(".0")) {
+    passTopicDescription = true
+    endpointSlug = "generate-learnpack-topic-intro-content"
+  } else {
+    passTopicDescription = true
+    endpointSlug = "generate-learnpack-subtopic-content"
+  }
 
   // Emit notification that initial content generation is starting
   emitToCourse(courseSlug, "course-creation", {
@@ -376,15 +390,20 @@ async function startInitialContentGeneration(
   // eslint-disable-next-line no-mixed-operators
   const randomCacheEvict = Math.floor(100_000 + Math.random() * 900_000)
 
+  const inputs = {
+    output_language: packageContext.language || "en",
+    current_syllabus: JSON.stringify(fullSyllabus),
+    lesson_description:
+      JSON.stringify(lessonCleaner(exercise)) + `-${randomCacheEvict}`,
+    target_word_count: String(PARAMS.max_words),
+    topic_description: passTopicDescription ?
+      String(exercise.description) :
+      undefined,
+  }
+
   const res = await initialContentGenerator(
     rigoToken.trim(),
-    {
-      // prev_lesson: lastLesson,
-      output_language: packageContext.language || "en",
-      current_syllabus: JSON.stringify(fullSyllabus),
-      lesson_description:
-        JSON.stringify(lessonCleaner(exercise)) + `-${randomCacheEvict}`,
-    },
+    inputs,
     webhookUrl,
     endpointSlug
   )
@@ -1897,6 +1916,13 @@ export default class ServeCommand extends SessionCommand {
 
         await uploadFileToBucket(bucket, body.parsed.translation, readmePath)
 
+        emitToCourse(courseSlug, "translation-completed", {
+          exercise: exSlug,
+          language: body.parsed.output_language_code,
+          status: "completed",
+          message: `Translation completed for ${exSlug} to ${body.parsed.output_language_code}`,
+        })
+
         res.json({ status: "SUCCESS" })
       }
     )
@@ -2245,23 +2271,22 @@ export default class ServeCommand extends SessionCommand {
       res.send({ message: "Files renamed" })
     })
 
-    app.post("/actions/translate", express.json(), async (req, res) => {
-      console.log("POST /actions/translate")
-      const { exerciseSlugs, languages, rigoToken, currentLanguage } = req.body
-      const query = req.query
-      const courseSlug = query.slug
-
-      if (!rigoToken) {
-        return res.status(400).json({ error: "RigoToken not found" })
-      }
-
-      const languagesToTranslate: string[] = languages.split(",")
-      const languageCodesRes = await getLanguageCodes(rigoToken, {
-        raw_languages: languagesToTranslate.join(","),
-      })
-      const languageCodes = languageCodesRes.parsed.language_codes
-
+    async function processTranslationsAsync(
+      courseSlug: string,
+      exerciseSlugs: string[],
+      languageCodes: string[],
+      rigoToken: string,
+      currentLanguage: string,
+      bucket: Bucket
+    ) {
       try {
+        emitToCourse(courseSlug, "translation-started", {
+          languages: languageCodes,
+          exercises: exerciseSlugs,
+          status: "started",
+          message: "Translation process started",
+        })
+
         await Promise.all(
           exerciseSlugs.map(async (slug: string) => {
             const readmePath = `courses/${courseSlug}/exercises/${slug}/README${getReadmeExtension(
@@ -2271,7 +2296,6 @@ export default class ServeCommand extends SessionCommand {
 
             await Promise.all(
               languageCodes.map(async (language: string) => {
-                // verify if the translation already exists
                 const translationPath = `courses/${courseSlug}/exercises/${slug}/README${getReadmeExtension(
                   language
                 )}`
@@ -2281,6 +2305,12 @@ export default class ServeCommand extends SessionCommand {
                   console.log(
                     `Translation in ${language} already exists for exercise ${slug}`
                   )
+                  emitToCourse(courseSlug, "translation-progress", {
+                    exercise: slug,
+                    language: language,
+                    status: "skipped",
+                    message: `Translation in ${language} already exists`,
+                  })
                   return
                 }
 
@@ -2292,6 +2322,13 @@ export default class ServeCommand extends SessionCommand {
                   },
                   `${process.env.HOST}/webhooks/${courseSlug}/${slug}/save-translation`
                 )
+
+                emitToCourse(courseSlug, "translation-progress", {
+                  exercise: slug,
+                  language: language,
+                  status: "initiated",
+                  message: `Translation job initiated for ${slug} to ${language}`,
+                })
               })
             )
           })
@@ -2339,8 +2376,6 @@ export default class ServeCommand extends SessionCommand {
           currentLanguages = Object.keys(courseJson.title)
         }
 
-        // Check that all the READMEs exists
-
         const missingReadmeTranslations = []
         let firstAvailable = ""
         for (const languageCode of currentLanguages) {
@@ -2363,6 +2398,7 @@ export default class ServeCommand extends SessionCommand {
 
         await Promise.all(
           missingReadmeTranslations.map(async languageCode => {
+             
             await translateExercise(
               rigoToken,
               {
@@ -2374,7 +2410,63 @@ export default class ServeCommand extends SessionCommand {
           })
         )
 
-        return res.status(200).json({ message: "Translated exercises" })
+        emitToCourse(courseSlug, "translation-initiated", {
+          status: "completed",
+          message: "All translation jobs have been initiated",
+          languages: languageCodes,
+          exercises: exerciseSlugs,
+        })
+      } catch (error) {
+        console.error("Error processing translations:", error)
+        emitToCourse(courseSlug, "translation-error", {
+          status: "error",
+          error: (error as Error).message,
+          message: "Error occurred during translation processing",
+        })
+        throw error
+      }
+    }
+
+    app.post("/actions/translate", express.json(), async (req, res) => {
+      console.log("POST /actions/translate")
+      const { exerciseSlugs, languages, rigoToken, currentLanguage } = req.body
+      const query = req.query
+      const courseSlug =
+        typeof query.slug === "string" ? query.slug : undefined
+
+      if (!rigoToken) {
+        return res.status(400).json({ error: "RigoToken not found" })
+      }
+
+      if (!courseSlug) {
+        return res.status(400).json({ error: "Course slug not found" })
+      }
+
+      const languagesToTranslate: string[] = languages.split(",")
+
+      try {
+        const languageCodesRes = await getLanguageCodes(rigoToken, {
+          raw_languages: languagesToTranslate.join(","),
+        })
+        const languageCodes = languageCodesRes.parsed.language_codes
+
+        res.status(200).json({
+          message: "Translation started",
+          languages: languageCodes,
+          exercises: exerciseSlugs,
+          status: "processing",
+        })
+
+        processTranslationsAsync(
+          courseSlug,
+          exerciseSlugs,
+          languageCodes,
+          rigoToken,
+          currentLanguage,
+          bucket
+        ).catch(error => {
+          console.error("Error in background translation processing:", error)
+        })
       } catch (error) {
         console.log(error, "ERROR")
         return res.status(400).json({ error: (error as Error).message })