@learnpack/learnpack 5.0.282 → 5.0.284

package/lib/commands/serve.js

@@ -526,6 +526,18 @@ class ServeCommand extends SessionCommand_1.default {
                     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 &&
@@ -541,7 +553,6 @@ class ServeCommand extends SessionCommand_1.default {
             else {
                 console.log("Stopping generation process at", exerciseIndex, exercise.title, "because it's a multiple of 3");
             }
-            const imagesArray = (0, creatorUtilities_1.extractImagesFromMarkdown)(readability.newMarkdown);
             const newSyllabus = Object.assign(Object.assign({}, syllabusJson), { lessons: syllabusJson.lessons.map((lesson, index) => {
                     if (index === exerciseIndex) {
                         const currentTranslations = lesson.translations || {};
@@ -1306,6 +1317,64 @@ class ServeCommand extends SessionCommand_1.default {
                 res.status(500).json({ error: "Failed to fetch the resource" });
             }
         });
+        app.get("/memory-bank/:courseSlug", async (req, res) => {
+            const { courseSlug } = req.params;
+            const rigoToken = req.header("x-rigo-token");
+            if (!rigoToken) {
+                return res.status(400).json({
+                    error: "Rigo token is required. x-rigo-token header is missing",
+                });
+            }
+            const { isAuthor } = await (0, rigoActions_1.isPackageAuthor)(rigoToken, courseSlug);
+            if (!isAuthor) {
+                return res.status(403).json({
+                    error: "You are not authorized to access the memory bank",
+                });
+            }
+            try {
+                const memoryBankPath = `courses/${courseSlug}/.learn/memory_bank.txt`;
+                const memoryBankFile = bucket.file(memoryBankPath);
+                const [exists] = await memoryBankFile.exists();
+                if (!exists) {
+                    return res.json({ content: "" });
+                }
+                const [content] = await memoryBankFile.download();
+                res.json({ content: content.toString() });
+            }
+            catch (error) {
+                console.error("❌ Error fetching memory bank:", error);
+                res.status(500).json({ error: "Failed to fetch memory bank" });
+            }
+        });
+        app.put("/memory-bank/:courseSlug", async (req, res) => {
+            const { courseSlug } = req.params;
+            const { content } = req.body;
+            const rigoToken = req.header("x-rigo-token");
+            if (!rigoToken) {
+                return res.status(400).json({
+                    error: "Rigo token is required. x-rigo-token header is missing",
+                });
+            }
+            if (!content) {
+                return res.status(400).json({ error: "Content is required" });
+            }
+            const { isAuthor } = await (0, rigoActions_1.isPackageAuthor)(rigoToken, courseSlug);
+            if (!isAuthor) {
+                return res.status(403).json({
+                    error: "You are not authorized to update the memory bank",
+                });
+            }
+            try {
+                const memoryBankPath = `courses/${courseSlug}/.learn/memory_bank.txt`;
+                await uploadFileToBucket(bucket, content, memoryBankPath);
+                console.log(`✅ Memory bank updated for course: ${courseSlug}`);
+                res.json({ message: "Memory bank updated successfully" });
+            }
+            catch (error) {
+                console.error("❌ Error updating memory bank:", error);
+                res.status(500).json({ error: "Failed to update memory bank" });
+            }
+        });
         // Export endpoint (POST) - supports both SCORM and EPUB
         app.post("/export/:course_slug/:format", async (req, res) => {
             const { course_slug, format } = req.params;

package/lib/creatorDist/assets/{index-BfLyIQVh.js → index-7zTdUX04.js}

@@ -21655,7 +21655,7 @@ function OT() {
       if (
         (oe && oe.toLowerCase().trim() === "true" && b(),
         I && (console.log("description", I), s({ description: I })),
-        ee && I && !isNaN(parseInt(ee)))
+        ee && !isNaN(parseInt(ee)))
       )
         if (["30", "60", "120"].includes(ee)) {
           const Q = parseInt(ee);
@@ -21667,8 +21667,8 @@ function OT() {
         U &&
           ["easy", "beginner", "intermediate", "hard"].includes(U) &&
           s({ difficulty: U }),
-        I && ee && ne && s({ currentStep: "hasContentIndex" }),
-        I && ee && !ne && s({ currentStep: "purpose" });
+        I && ne && s({ currentStep: "duration" }),
+        I && !ne && s({ currentStep: "purpose" });
     },
     F = async () => {
       try {
@@ -21747,6 +21747,20 @@ function OT() {
             },
           }),
         },
+        {
+          title: t("stepWizard.purpose"),
+          slug: "purpose",
+          isCompleted:
+            ((ee = i == null ? void 0 : i.purpose) == null
+              ? void 0
+              : ee.length) > 0,
+          required: !0,
+          content: E.jsx(DT, {
+            onFinish: (te) => {
+              s({ purpose: te, currentStep: "verifyHuman" });
+            },
+          }),
+        },
         {
           title: t("stepWizard.duration"),
           slug: "duration",
@@ -21758,41 +21772,27 @@ function OT() {
               E.jsx(kr, {
                 title: t("stepWizard.durationCard.30"),
                 onClick: () => {
-                  s({ duration: 30, currentStep: "purpose" });
+                  s({ duration: 30, currentStep: "verifyHuman" });
                 },
                 selected: i.duration === 30,
               }),
               E.jsx(kr, {
                 title: t("stepWizard.durationCard.60"),
                 onClick: () => {
-                  s({ duration: 60, currentStep: "purpose" });
+                  s({ duration: 60, currentStep: "verifyHuman" });
                 },
                 selected: i.duration === 60,
               }),
               E.jsx(kr, {
                 title: t("stepWizard.durationCard.120"),
                 onClick: () => {
-                  s({ duration: 120, currentStep: "purpose" });
+                  s({ duration: 120, currentStep: "verifyHuman" });
                 },
                 selected: i.duration === 120,
               }),
             ],
           }),
         },
-        {
-          title: t("stepWizard.purpose"),
-          slug: "purpose",
-          isCompleted:
-            ((ee = i == null ? void 0 : i.purpose) == null
-              ? void 0
-              : ee.length) > 0,
-          required: !0,
-          content: E.jsx(DT, {
-            onFinish: (te) => {
-              s({ purpose: te, currentStep: "verifyHuman" });
-            },
-          }),
-        },
         {
           title: t("stepWizard.verifyHuman"),
           slug: "verifyHuman",
@@ -21807,11 +21807,11 @@ function OT() {
                   console.log("JWT TOKEN received", oe),
                   l({ ...y, publicToken: oe }),
                   s({ currentStep: "hasContentIndex" }))
-                : (Ge.error(re), s({ currentStep: "purpose" }));
+                : (Ge.error(re), s({ currentStep: "duration" }));
             },
             onError: () => {
               Ge.error(t("turnstileModal.error"), { duration: 1e4 }),
-                s({ currentStep: "purpose" });
+                s({ currentStep: "duration" });
             },
           }),
         },

package/lib/creatorDist/index.html

@@ -10,7 +10,7 @@
     />
 
     <title>Learnpack Creator: Craft tutorials in seconds!</title>
-    <script type="module" crossorigin src="/creator/assets/index-BfLyIQVh.js"></script>
+    <script type="module" crossorigin src="/creator/assets/index-7zTdUX04.js"></script>
     <link rel="stylesheet" crossorigin href="/creator/assets/index-C39zeF3W.css">
   </head>
   <body>

package/lib/utils/export/epub.js

@@ -14,7 +14,7 @@ const replaceQuestionsFromMarkdown = (markdown) => {
     // some text
     // ```
     const questionRegex = /```question([\s\S]*?)```/g;
-    return markdown.replace(questionRegex, "");
+    return markdown.replace(questionRegex, '<div type="text" class="open-question">Right your answer here</div>');
 };
 const replaceMermaidFromMarkdown = (markdown) => {
     // Search for all code blocks like this (No breaking lines sensitive)
@@ -24,6 +24,12 @@ const replaceMermaidFromMarkdown = (markdown) => {
     const mermaidRegex = /```mermaid([\s\S]*?)```/g;
     return markdown.replace(mermaidRegex, "");
 };
+const cleanQuizOptions = (markdown) => {
+    // Remove [x] from quiz options, keeping only [ ] for all options
+    // This handles both - [x] and - [x] patterns
+    const quizRegex = /^(\s*-\s*)\[x\](\s+.*)$/gm;
+    return markdown.replace(quizRegex, "$1[ ]$2");
+};
 // Download cover image from bucket
 async function downloadCoverImage(bucket, courseSlug, outputDir) {
     try {
@@ -40,95 +46,8 @@ async function downloadCoverImage(bucket, courseSlug, outputDir) {
         return undefined;
     }
 }
-// Convert markdown to HTML using pandoc
-async function convertMarkdownToHtml(markdownPath, outputPath, learnAssetsDir) {
-    return new Promise((resolve, reject) => {
-        let stdout = "";
-        let stderr = "";
-        // Process markdown content to fix image paths
-        let markdownContent = fs.readFileSync(markdownPath, "utf-8");
-        if (learnAssetsDir && fs.existsSync(learnAssetsDir)) {
-            // Find all image references in markdown
-            const imageRegex = /!\[([^\]]*)\]\(([^)]+)\)/g;
-            let match;
-            let imageCount = 0;
-            while ((match = imageRegex.exec(markdownContent)) !== null) {
-                const [fullMatch, altText, imagePath] = match;
-                // Check if it's a relative path starting with /learn/assets/
-                if (imagePath.startsWith("/.learn/assets/")) {
-                    const imageName = path.basename(imagePath);
-                    const absoluteImagePath = path.join(learnAssetsDir, imageName);
-                    console.log(`📸 Looking for image: ${imageName}`);
-                    console.log(`📁 Learn assets dir: ${learnAssetsDir}`);
-                    console.log(`📁 Absolute path: ${absoluteImagePath}`);
-                    console.log(`📁 Path exists: ${fs.existsSync(absoluteImagePath)}`);
-                    if (fs.existsSync(absoluteImagePath)) {
-                        // Use absolute path for the image
-                        console.log(`✅ Found image, replacing path: ${imagePath} -> ${absoluteImagePath}`);
-                        markdownContent = markdownContent.replace(fullMatch, `![${altText}](${absoluteImagePath})`);
-                        imageCount++;
-                    }
-                    else {
-                        console.log(`❌ Image not found: ${absoluteImagePath}`);
-                        // List files in the assets directory for debugging
-                        if (fs.existsSync(learnAssetsDir)) {
-                            const files = fs.readdirSync(learnAssetsDir);
-                            console.log(`📁 Files in assets directory: ${files.join(", ")}`);
-                        }
-                        else {
-                            console.log(`❌ Assets directory does not exist: ${learnAssetsDir}`);
-                        }
-                    }
-                }
-            }
-        }
-        markdownContent = replaceQuestionsFromMarkdown(markdownContent);
-        markdownContent = replaceMermaidFromMarkdown(markdownContent);
-        // Write processed markdown to a temporary file
-        const tempMarkdownPath = markdownPath + ".processed";
-        fs.writeFileSync(tempMarkdownPath, markdownContent, "utf-8");
-        const pandocArgs = [
-            tempMarkdownPath,
-            "-o",
-            outputPath,
-            "--from",
-            "markdown",
-            "--to",
-            "html",
-            "--standalone",
-            "--css",
-            path.join(__dirname, "../templates/epub/epub.css"),
-        ];
-        const pandoc = (0, child_process_1.spawn)("pandoc", pandocArgs);
-        pandoc.stdout.on("data", (data) => {
-            stdout += data.toString();
-        });
-        pandoc.stderr.on("data", (data) => {
-            stderr += data.toString();
-        });
-        pandoc.on("close", (code) => {
-            // Clean up temporary file
-            // if (fs.existsSync(tempMarkdownPath)) {
-            //   fs.unlinkSync(tempMarkdownPath);
-            // }
-            if (code === 0) {
-                console.log("Successfully converted:", markdownPath, "->", outputPath);
-                resolve();
-            }
-            else {
-                const errorMessage = `Pandoc process exited with code ${code}\n\nSTDOUT:\n${stdout}\n\nSTDERR:\n${stderr}`;
-                console.error("Pandoc Error Details:", errorMessage);
-                reject(new Error(errorMessage));
-            }
-        });
-        pandoc.on("error", (err) => {
-            console.error("Pandoc spawn error:", err);
-            reject(err);
-        });
-    });
-}
-// Generate EPUB using pandoc
-async function generateEpub(htmlFiles, outputPath, metadata, epubMetadata, coverImagePath) {
+// Generate EPUB using pandoc directly from markdown files
+async function generateEpub(markdownFiles, outputPath, metadata, epubMetadata, coverImagePath) {
     return new Promise((resolve, reject) => {
         var _a;
         let stdout = "";
@@ -149,13 +68,13 @@ description: "${escapeYaml(metadata.description || "")}"
 subject: "${((_a = metadata.technologies) === null || _a === void 0 ? void 0 : _a.join(", ")) || "Programming"}"
 ---`;
         fs.writeFileSync(yamlPath, yamlContent, "utf-8");
-        // Include all HTML files in the EPUB
+        // Include all markdown files in the EPUB
         const pandocArgs = [
-            ...htmlFiles, // All HTML files
+            ...markdownFiles, // All markdown files
             "-o",
             outputPath,
             "--from",
-            "html",
+            "markdown",
             "--to",
             "epub",
             "--metadata-file",
@@ -198,16 +117,16 @@ subject: "${((_a = metadata.technologies) === null || _a === void 0 ? void 0 : _
         });
     });
 }
-// Process exercises and convert to HTML
+// Process exercises and collect markdown files for direct EPUB conversion
 async function processExercises(exercisesDir, outputDir, language = "en", learnAssetsDir) {
-    const htmlFiles = [];
+    const processedMarkdownFiles = [];
     console.log("Processing exercises directory:", exercisesDir);
     console.log("Output directory:", outputDir);
     console.log("Language:", language);
     console.log("Learn assets directory:", learnAssetsDir);
     if (!fs.existsSync(exercisesDir)) {
         console.log("Exercises directory does not exist:", exercisesDir);
-        return htmlFiles;
+        return processedMarkdownFiles;
     }
     console.log("Exercises directory exists, scanning for files...");
     const processDirectory = async (dir, relativePath = "") => {
@@ -265,26 +184,25 @@ async function processExercises(exercisesDir, outputDir, language = "en", learnA
                         console.log(`✅ Including ${language} file: ${relativeFilePath}`);
                     }
                 }
-                // Convert markdown to HTML
-                console.log("Converting markdown file:", relativeFilePath);
-                // const htmlFileName = entry.name.replace(/\.(md|markdown)$/, ".html");
-                const htmlPath = path.join(outputDir, relativeFilePath.replace(/\.(md|markdown)$/, ".html"));
-                console.log("HTML output path:", htmlPath);
-                mkdirp.sync(path.dirname(htmlPath));
-                // esling-disable-next-line
-                await convertMarkdownToHtml(fullPath, htmlPath, learnAssetsDir);
-                htmlFiles.push(htmlPath);
-                console.log("Successfully converted:", relativeFilePath, "->", htmlPath);
+                // Process markdown content and save to output directory
+                console.log("Processing markdown file:", relativeFilePath);
+                const processedContent = processMarkdownContent(fullPath, learnAssetsDir);
+                const processedMarkdownPath = path.join(outputDir, relativeFilePath.replace(/\.(md|markdown)$/, ".processed.md"));
+                console.log("Processed markdown output path:", processedMarkdownPath);
+                mkdirp.sync(path.dirname(processedMarkdownPath));
+                fs.writeFileSync(processedMarkdownPath, processedContent, "utf-8");
+                processedMarkdownFiles.push(processedMarkdownPath);
+                console.log("Successfully processed:", relativeFilePath, "->", processedMarkdownPath);
             }
             else if (entry.name.endsWith(".html")) {
-                // Copy HTML files as-is
-                console.log("Copying HTML file:", relativeFilePath);
-                const destPath = path.join(outputDir, relativeFilePath);
-                mkdirp.sync(path.dirname(destPath));
-                // esling-disable-next-line
-                fs.copyFileSync(fullPath, destPath);
-                htmlFiles.push(destPath);
-                console.log("Successfully copied:", relativeFilePath, "->", destPath);
+                // Convert HTML files to markdown for consistency
+                console.log("Converting HTML file to markdown:", relativeFilePath);
+                const htmlContent = fs.readFileSync(fullPath, "utf-8");
+                const processedMarkdownPath = path.join(outputDir, relativeFilePath.replace(/\.html$/, ".processed.md"));
+                mkdirp.sync(path.dirname(processedMarkdownPath));
+                fs.writeFileSync(processedMarkdownPath, htmlContent, "utf-8");
+                processedMarkdownFiles.push(processedMarkdownPath);
+                console.log("Successfully converted HTML:", relativeFilePath, "->", processedMarkdownPath);
             }
             else {
                 console.log("Skipping file:", relativeFilePath, "(not markdown or HTML)");
@@ -292,7 +210,48 @@ async function processExercises(exercisesDir, outputDir, language = "en", learnA
         }
     };
     await processDirectory(exercisesDir);
-    return htmlFiles;
+    return processedMarkdownFiles;
+}
+// Process markdown content for EPUB conversion
+function processMarkdownContent(markdownPath, learnAssetsDir) {
+    let markdownContent = fs.readFileSync(markdownPath, "utf-8");
+    if (learnAssetsDir && fs.existsSync(learnAssetsDir)) {
+        // Find all image references in markdown
+        const imageRegex = /!\[([^\]]*)\]\(([^)]+)\)/g;
+        let match;
+        while ((match = imageRegex.exec(markdownContent)) !== null) {
+            const [fullMatch, altText, imagePath] = match;
+            // Check if it's a relative path starting with /learn/assets/
+            if (imagePath.startsWith("/.learn/assets/")) {
+                const imageName = path.basename(imagePath);
+                const absoluteImagePath = path.join(learnAssetsDir, imageName);
+                console.log(`📸 Looking for image: ${imageName}`);
+                console.log(`📁 Learn assets dir: ${learnAssetsDir}`);
+                console.log(`📁 Absolute path: ${absoluteImagePath}`);
+                console.log(`📁 Path exists: ${fs.existsSync(absoluteImagePath)}`);
+                if (fs.existsSync(absoluteImagePath)) {
+                    // Use absolute path for the image
+                    console.log(`✅ Found image, replacing path: ${imagePath} -> ${absoluteImagePath}`);
+                    markdownContent = markdownContent.replace(fullMatch, `![${altText}](${absoluteImagePath})`);
+                }
+                else {
+                    console.log(`❌ Image not found: ${absoluteImagePath}`);
+                    // List files in the assets directory for debugging
+                    if (fs.existsSync(learnAssetsDir)) {
+                        const files = fs.readdirSync(learnAssetsDir);
+                        console.log(`📁 Files in assets directory: ${files.join(", ")}`);
+                    }
+                    else {
+                        console.log(`❌ Assets directory does not exist: ${learnAssetsDir}`);
+                    }
+                }
+            }
+        }
+    }
+    markdownContent = replaceQuestionsFromMarkdown(markdownContent);
+    markdownContent = replaceMermaidFromMarkdown(markdownContent);
+    markdownContent = cleanQuizOptions(markdownContent);
+    return markdownContent;
 }
 const titlelify = (title) => {
     return title.replace(/[-_]/g, " ").replace(/\b\w/g, (l) => l.toUpperCase());
@@ -311,52 +270,6 @@ function readSidebarData(learnDir) {
     }
     return null;
 }
-// Create EPUB table of contents
-function createTocHtml(htmlFiles, metadata, sidebarData, language) {
-    let tocContent = `
-<!DOCTYPE html>
-<html>
-<head>
-    <meta charset="UTF-8">
-    <title>Table of Contents - ${metadata.title}</title>
-    <link rel="stylesheet" href="epub.css">
-</head>
-<body>
-    <h1>${metadata.title}</h1>
-    <nav id="toc">
-        <h2>Table of Contents</h2>
-        <ol>
-            <li><a href="main.html">Course Overview</a></li>
-`;
-    htmlFiles.forEach((file) => {
-        const fileName = path.basename(file, ".html");
-        const relativePath = fileName + ".html";
-        // Get the parent directory name (exercise slug) to look up in sidebar
-        const parentDir = path.basename(path.dirname(file));
-        // Try to get the title from sidebar.json using the parent directory name
-        let displayName = fileName;
-        if (sidebarData && sidebarData[parentDir]) {
-            console.log("🔍 Found title in sidebar.json:", sidebarData[parentDir], "; language: ", language);
-            // Get the title for the current language, fallback to English, then to the key itself
-            displayName =
-                sidebarData[parentDir][language] ||
-                    sidebarData[parentDir]["en"] ||
-                    titlelify(parentDir);
-        }
-        else {
-            console.log("🔍 No title found in sidebar.json for parent directory:", parentDir);
-            // Fallback to titlelify if not found in sidebar
-            displayName = titlelify(parentDir);
-        }
-        tocContent += `            <li><a href="${relativePath}">${displayName}</a></li>\n`;
-    });
-    tocContent += `
-        </ol>
-    </nav>
-</body>
-</html>`;
-    return tocContent;
-}
 async function exportToEpub(options, epubMetadata) {
     var _a, _b, _c;
     const { courseSlug, bucket, outDir, language = "en" } = options;
@@ -394,8 +307,8 @@ async function exportToEpub(options, epubMetadata) {
         difficulty: learnJson.difficulty || "beginner",
     };
     console.log("Course metadata:", metadata);
-    // 5. Process exercises and convert to HTML
-    console.log("🔄 Processing exercises and converting to HTML...");
+    // 5. Process exercises and prepare markdown files
+    console.log("🔄 Processing exercises and preparing markdown files...");
     // First, let's see what files were downloaded
     const exercisesPath = path.join(epubOutDir, "exercises");
     console.log("📂 Exercises directory contents:");
@@ -413,44 +326,60 @@ async function exportToEpub(options, epubMetadata) {
     else {
         console.log("❌ Exercises directory does not exist!");
     }
-    const htmlFiles = await processExercises(path.join(epubOutDir, "exercises"), path.join(epubOutDir, "html"), language, path.join(epubOutDir, "learn", "assets"));
+    const processedMarkdownFiles = await processExercises(path.join(epubOutDir, "exercises"), path.join(epubOutDir, "processed"), language, path.join(epubOutDir, "learn", "assets"));
     // 6. Read sidebar data and create table of contents
     const sidebarData = readSidebarData(path.join(epubOutDir, "learn"));
     console.log("📋 Sidebar data loaded:", sidebarData ? "Success" : "Not found");
-    const tocHtml = createTocHtml(htmlFiles, metadata, sidebarData, language);
-    const tocPath = path.join(epubOutDir, "html", "toc.html");
-    mkdirp.sync(path.dirname(tocPath));
-    fs.writeFileSync(tocPath, tocHtml, "utf-8");
-    // 7. Create main content file
-    const mainContent = `
-<!DOCTYPE html>
-<html>
-<head>
-    <meta charset="UTF-8">
-    <title>${metadata.title}</title>
-    <link rel="stylesheet" href="epub.css">
-</head>
-<body>
-    <h1>${metadata.title}</h1>
-    <p>${metadata.description || ""}</p>
-    <p><strong>Technologies:</strong> ${((_c = metadata.technologies) === null || _c === void 0 ? void 0 : _c.join(", ")) || "Programming"}</p>
-    <p><strong>Difficulty:</strong> ${metadata.difficulty}</p>
-    <p><strong>Language:</strong> ${language}</p>
-    <p><a href="toc.html">Go to Table of Contents</a></p>
-</body>
-</html>`;
-    const mainContentPath = path.join(epubOutDir, "html", "main.html");
+    // 7. Create main content file as markdown
+    const mainContent = `# ${metadata.title}
+
+${metadata.description || ""}
+
+**Technologies:** ${((_c = metadata.technologies) === null || _c === void 0 ? void 0 : _c.join(", ")) || "Programming"}
+
+**Difficulty:** ${metadata.difficulty}
+
+**Language:** ${language}
+
+---
+
+## Table of Contents
+
+${processedMarkdownFiles
+        .map((file, index) => {
+        const fileName = path.basename(file, ".processed.md");
+        const parentDir = path.basename(path.dirname(file));
+        // Get the title from sidebar.json using the parent directory name
+        let displayName = fileName;
+        if (sidebarData && sidebarData[parentDir]) {
+            displayName =
+                sidebarData[parentDir][language] ||
+                    sidebarData[parentDir]["en"] ||
+                    titlelify(parentDir);
+        }
+        else {
+            displayName = titlelify(parentDir);
+        }
+        return `${index + 1}. ${displayName}`;
+    })
+        .join("\n")}
+
+---
+
+`;
+    const mainContentPath = path.join(epubOutDir, "processed", "main.md");
+    mkdirp.sync(path.dirname(mainContentPath));
     fs.writeFileSync(mainContentPath, mainContent, "utf-8");
-    // 8. Prepare all HTML files for EPUB generation
-    const allHtmlFiles = [mainContentPath, tocPath, ...htmlFiles];
+    // 8. Prepare all markdown files for EPUB generation
+    const allMarkdownFiles = [mainContentPath, ...processedMarkdownFiles];
     // 9. Generate EPUB using pandoc
     console.log("📖 Generating EPUB file...");
     const epubPath = path.join(epubOutDir, `${courseSlug}.epub`);
-    await generateEpub(allHtmlFiles, epubPath, metadata, epubMetadata, coverImagePath);
+    await generateEpub(allMarkdownFiles, epubPath, metadata, epubMetadata, coverImagePath);
     console.log("EPUB generated successfully:", epubPath);
     // Clean up temporary files
     console.log("Cleaning up temporary files...");
-    rimraf.sync(path.join(epubOutDir, "html"));
+    rimraf.sync(path.join(epubOutDir, "processed"));
     rimraf.sync(path.join(epubOutDir, "exercises"));
     rimraf.sync(path.join(epubOutDir, "learn"));
     console.log("EPUB export completed successfully");

package/lib/utils/templates/epub/epub.css

@@ -131,3 +131,16 @@ th {
   color: #2c3e50;
   font-weight: 500;
 }
+
+/* Open question styles */
+.open-question {
+  border: 1px solid #c2c2c2;
+  padding: 1em;
+  background-color: #fafafa;
+  margin: 1em 0;
+  width: 100%;
+  height: 150px;
+  color: #c2c2c2;
+  border-radius: 5px;
+  font-style: italic;
+}

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.282",
+  "version": "5.0.284",
   "author": "Alejandro Sanchez @alesanchezr",
   "contributors": [
     {