@learnpack/learnpack 5.0.33 → 5.0.35

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.33",
+  "version": "5.0.35",
   "author": "Alejandro Sanchez @alesanchezr",
   "contributors": [
     {
@@ -42,6 +42,7 @@
     "express": "^4.17.1",
     "front-matter": "^4.0.2",
     "js-yaml": "^4.1.0",
+    "markdown-it": "^14.1.0",
     "moment": "^2.27.0",
     "node-emoji": "^1.10.0",
     "node-fetch": "^2.7.0",
@@ -49,6 +50,7 @@
     "prompts": "^2.3.2",
     "shelljs": "^0.8.4",
     "socket.io": "^4.4.1",
+    "syllable": "^5.0.1",
     "targz": "^1.0.1",
     "text-readability": "^1.1.0",
     "tslib": "^1",
@@ -63,6 +65,7 @@
     "@types/express": "^4.17.13",
     "@types/fs-extra": "^8.1.0",
     "@types/js-yaml": "^4.0.9",
+    "@types/markdown-it": "^14.1.2",
     "@types/mocha": "^5",
     "@types/mock-fs": "^4.13.1",
     "@types/node": "^22.13.5",

package/src/commands/breakToken.ts

@@ -1,36 +1,67 @@
-import { flags } from "@oclif/command"
-import BaseCommand from "../utils/BaseCommand"
-// eslint-disable-next-line
-import * as fs from "fs-extra"
-import Console from "../utils/console"
-
-import SessionManager from "../managers/session"
-import { createFileOnDesktop, getContentIndex } from "../utils/creatorUtilities"
-
-class BreakTokenCommand extends BaseCommand {
-  static description = "Break the token"
-
-  static flags = {
-    ...BaseCommand.flags,
-    grading: flags.help({ char: "h" }),
-  }
-
-  async run() {
-    const { flags } = this.parse(BreakTokenCommand)
-
-    // await SessionManager.breakToken()
-    await createFileOnDesktop()
-    Console.info(
-      "File created on desktop, please make the necessary changes and continue when ready"
-    )
-
-    // Wait for user to press enter
-    process.stdin.once("data", () => {
-      Console.info("File content:")
-      Console.info(getContentIndex())
-      process.exit(0)
-    })
-  }
-}
-
-export default BreakTokenCommand
+import { flags } from "@oclif/command"
+import BaseCommand from "../utils/BaseCommand"
+ 
+import Console from "../utils/console"
+
+import {
+  extractParagraphs,
+  splitIntoSyllables,
+  extractWords,
+  countSentences,
+  fleschKincaidGrade,
+} from "../utils/creatorUtilities"
+
+const exampleMd = `# How to Install Node.js
+
+Node.js lets you run JavaScript outside a web browser.
+
+## Step 1: Download Node.js
+
+Get the Node.js installer from the [official site](https://nodejs.org/en/download/).
+
+## Step 2: Install Node.js
+
+Open the installer and follow the steps to finish.
+
+## Step 3: Verify the Installation
+
+Open a terminal and type:
+
+\`\`\`bash
+node -v
+\`\`\`
+`
+
+class BreakTokenCommand extends BaseCommand {
+  static description = "Break the token"
+
+  static flags = {
+    ...BaseCommand.flags,
+    grading: flags.help({ char: "h" }),
+  }
+
+  async run() {
+    const { flags } = this.parse(BreakTokenCommand)
+
+    // await SessionManager.breakToken()
+    const paragraphs = extractParagraphs(exampleMd)
+    for (const paragraph of paragraphs) {
+      const syllables = splitIntoSyllables(paragraph)
+      const words = extractWords(paragraph)
+      const sentences = countSentences(paragraph)
+      const fkgl = fleschKincaidGrade(paragraph)
+      Console.info(paragraph)
+      Console.info(`Number of syllables: ${syllables.length}`)
+      Console.info(syllables)
+      Console.info(`Number of words: ${words.length}`)
+      Console.info(words)
+      Console.info(`Number of sentences: ${sentences}`)
+      Console.info(`FKGL: ${fkgl}`)
+      Console.info("---")
+    }
+
+    process.exit(0)
+  }
+}
+
+export default BreakTokenCommand

package/src/commands/init.ts

@@ -19,12 +19,12 @@ import {
   createCodeFile,
   readmeCreator,
   createPreviewReadme,
-  reduceReadme,
+  makeReadmeReadable,
   isValidRigoToken,
 } from "../utils/rigoActions"
 import { getConsumable } from "../utils/api"
 import {
-  checkReadingTime,
+  checkReadability,
   PackageInfo,
   getExInfo,
   extractImagesFromMarkdown,
@@ -42,6 +42,13 @@ const durationByKind: Record<string, number> = {
   read: 1,
 }
 
+const PARAMS = {
+  expected_grade_level: "6",
+  max_fkgl: 8,
+  max_words: 200,
+  max_rewrite_attempts: 3,
+}
+
 const whichTargetAudience = async () => {
   const res = await prompts([
     {
@@ -53,6 +60,94 @@ const whichTargetAudience = async () => {
   return res.targetAudience
 }
 
+async function processExercise(
+  rigoToken: string,
+  steps: string[],
+  packageContext: string,
+  exercise: any,
+  exercisesDir: string
+): Promise<string> {
+  const { exNumber, exTitle, kind, description } = getExInfo(exercise)
+  const exerciseDir = path.join(exercisesDir, `${exNumber}-${exTitle}`)
+
+  const readme = await readmeCreator(rigoToken, {
+    title: `${exNumber} - ${exTitle}`,
+    output_lang: "en",
+    list_of_exercises: steps.join(","),
+    tutorial_description: packageContext,
+    lesson_description: description,
+    kind: kind.toLowerCase(),
+  })
+
+  const duration = durationByKind[kind.toLowerCase()]
+  let attempts = 0
+  let readability = checkReadability(readme.parsed.content, 200, duration || 1)
+
+  while (
+    readability.fkglResult.fkgl > PARAMS.max_fkgl &&
+    attempts < PARAMS.max_rewrite_attempts
+  ) {
+    Console.warning(
+      `The lesson ${exTitle} has as readability score of  ${
+        readability.fkglResult.fkgl
+      } . It exceeds the maximum of words per minute. Rewriting it... (Attempt ${
+        attempts + 1
+      })`
+    )
+
+    // eslint-disable-next-line
+    const reducedReadme = await makeReadmeReadable(rigoToken, {
+      lesson: readability.body,
+      number_of_words: readability.minutes.toString(),
+      expected_number_words: PARAMS.max_words.toString(),
+      fkgl_results: JSON.stringify(readability.fkglResult),
+      expected_grade_level: PARAMS.expected_grade_level,
+    })
+
+    if (!reducedReadme) 
+break
+
+    readability = checkReadability(
+      reducedReadme.parsed.content,
+      PARAMS.max_words,
+      duration || 1
+    )
+
+    attempts++
+  }
+
+  Console.success(
+    `After ${attempts} attempts, the lesson ${exTitle} has a readability score of ${
+      readability.fkglResult.fkgl
+    } using FKGL. And it has ${readability.minutes.toFixed(
+      2
+    )} minutes of reading time.`
+  )
+
+  const readmeFilename = "README.md"
+  fs.writeFileSync(
+    path.join(exerciseDir, readmeFilename),
+    readability.newMarkdown
+  )
+
+  if (kind.toLowerCase() === "code") {
+    const codeFile = await createCodeFile(rigoToken, {
+      readme: readability.newMarkdown,
+      tutorial_info: packageContext,
+    })
+
+    fs.writeFileSync(
+      path.join(
+        exerciseDir,
+        `app.${codeFile.parsed.extension.replace(".", "")}`
+      ),
+      codeFile.parsed.content
+    )
+  }
+
+  return readability.newMarkdown
+}
+
 const initializeInteractiveCreation = async (
   rigoToken: string,
   courseInfo: string
@@ -252,69 +347,9 @@ const handleAILogic = async (tutorialDir: string, packageInfo: PackageInfo) => {
     fs.ensureDirSync(exerciseDir)
   }
 
-  const exercisePromises = steps.map(async (exercise: any, index: number) => {
-    const { exNumber, exTitle, kind, description } = getExInfo(exercise)
-    const exerciseDir = path.join(exercisesDir, `${exNumber}-${exTitle}`)
-
-    const readme = await readmeCreator(rigoToken, {
-      title: `${exNumber} - ${exTitle}`,
-      output_lang: "en",
-      list_of_exercises: steps.join(","),
-      tutorial_description: packageContext,
-      lesson_description: description,
-      kind: kind.toLowerCase(),
-    })
-
-    const duration = durationByKind[kind.toLowerCase()]
-    let readingTime = checkReadingTime(
-      readme.parsed.content,
-      200,
-      duration || 1
-    )
-
-    if (readingTime.exceedsThreshold) {
-      // Console.info(
-      //   `The reading time for the lesson ${exTitle} exceeds the threshold, reducing it...`
-      // )
-      const reducedReadme = await reduceReadme(rigoToken, {
-        lesson: readingTime.body,
-        number_of_words: readingTime.minutes.toString(),
-        expected_number_words: "200",
-      })
-
-      if (reducedReadme) {
-        readingTime = checkReadingTime(
-          reducedReadme.parsed.content,
-          200,
-          duration || 1
-        )
-      }
-    }
-
-    const readmeFilename = "README.md"
-
-    fs.writeFileSync(
-      path.join(exerciseDir, readmeFilename),
-      readingTime.newMarkdown
-    )
-
-    if (kind.toLowerCase() === "code") {
-      const codeFile = await createCodeFile(rigoToken, {
-        readme: readme.parsed.content,
-        tutorial_info: packageContext,
-      })
-
-      fs.writeFileSync(
-        path.join(
-          exerciseDir,
-          `app.${codeFile.parsed.extension.replace(".", "")}`
-        ),
-        codeFile.parsed.content
-      )
-    }
-
-    return readingTime.newMarkdown
-  })
+  const exercisePromises = steps.map(exercise =>
+    processExercise(rigoToken, steps, packageContext, exercise, exercisesDir)
+  )
 
   const readmeContents = await Promise.all(exercisePromises)
   Console.success("Lessons created! 🎉")

package/src/managers/config/exercise.ts

@@ -9,7 +9,7 @@ import { IFile } from "../../models/file"
 import { IExercise } from "../../models/exercise-obj"
 
 // eslint-disable-next-line
-const frontMatter = require("front-matter");
+const frontMatter = require("front-matter")
 
 export const exercise = (
   path: string,
@@ -140,6 +140,23 @@ continue
 
       return content
     },
+
+    renameFolder: function (newName: string) {
+      if (!config?.dirPath) {
+        throw new Error("No config directory found")
+      }
+
+      try {
+        const newPath = p.join(config?.exercisesPath, newName)
+        fs.renameSync(this.path, newPath)
+        this.path = newPath
+        this.slug = newName
+        this.title = newName
+      } catch (error) {
+        console.log(error)
+        throw new Error("Failed to rename exercise: " + error)
+      }
+    },
     saveFile: function (name: string, content: string) {
       const file: IFile | undefined = this.files.find(
         (f: IFile) => f.name === name

package/src/managers/server/routes.ts

@@ -453,6 +453,32 @@ throw new Error("File not found: " + filePath)
     })
   )
 
+  app.put(
+    "/actions/rename",
+    jsonBodyParser,
+    withHandler(async (req: express.Request, res: express.Response) => {
+      const { slug, newSlug } = req.body
+      const exercise = configManager.getExercise(slug)
+      if (!exercise) {
+        return res.status(400).json({ error: "Exercise not found" })
+      }
+
+      try {
+        if (exercise.renameFolder) {
+          exercise.renameFolder(newSlug)
+          res.json({ status: "ok" })
+        } else {
+          res.status(500).json({
+            error:
+              "Failed to rename exercise because it's not supported by the exercise",
+          })
+        }
+      } catch {
+        res.status(500).json({ error: "Failed to rename exercise" })
+      }
+    })
+  )
+
   app.post(
     "/exercise/:slug/create",
     jsonBodyParser,

package/src/models/exercise-obj.ts

@@ -1,29 +1,30 @@
-import { IFile } from "./file"
-import { IConfig } from "./config"
-import { ISocket } from "./socket"
-
-export interface IExercise {
-  position?: number;
-  files: Array<IFile>;
-  slug: string;
-  path: string;
-  done: boolean;
-  language?: string | null;
-  entry?: string | null;
-  graded?: boolean;
-  translations?: { [key: string]: string };
-  title: string;
-  getReadme?: (lang: string | null) => any;
-  getFile?: (name: string) => string | Buffer;
-  saveFile?: (name: string, content: string) => void;
-  getTestReport?: () => any;
-  test?: (sessionConfig: any, config: IConfig, socket: ISocket) => void;
-}
-
-export interface IExerciseData {
-  lastMessages?: any;
-  userMessage?: string;
-  exerciseSlug: string;
-  entryPoint?: string;
-  files: string[];
-}
+import { IFile } from "./file"
+import { IConfig } from "./config"
+import { ISocket } from "./socket"
+
+export interface IExercise {
+  position?: number
+  files: Array<IFile>
+  slug: string
+  path: string
+  done: boolean
+  language?: string | null
+  entry?: string | null
+  graded?: boolean
+  translations?: { [key: string]: string }
+  title: string
+  getReadme?: (lang: string | null) => any
+  getFile?: (name: string) => string | Buffer
+  saveFile?: (name: string, content: string) => void
+  renameFolder?: (newName: string) => void
+  getTestReport?: () => any
+  test?: (sessionConfig: any, config: IConfig, socket: ISocket) => void
+}
+
+export interface IExerciseData {
+  lastMessages?: any
+  userMessage?: string
+  exerciseSlug: string
+  entryPoint?: string
+  files: string[]
+}

package/src/utils/creatorUtilities.ts

@@ -1,5 +1,8 @@
+import Console from "./console"
 
 const frontMatter = require("front-matter")
+import * as MarkdownIt from "markdown-it"
+import { syllable } from "syllable"
 
 import * as path from "path"
 import * as fs from "fs"
@@ -53,7 +56,12 @@ export type PackageInfo = {
   }
 }
 
-export function checkReadingTime(
+type TFKGLResult = {
+  text: string
+  fkgl: number
+}
+
+export function checkReadability(
   markdown: string,
   wordsPerMinute = 200,
   maxMinutes = 1
@@ -62,10 +70,13 @@ export function checkReadingTime(
   exceedsThreshold: boolean
   minutes: number
   body: string
+  fkglResult: TFKGLResult
   // readingEase: number
 } {
   const parsed = frontMatter(markdown)
 
+  const fkglResult = fleschKincaidGrade(parsed.body)
+
   const readingTime = estimateReadingTime(parsed.body, wordsPerMinute)
 
   // const readingEase = estimateReadingEase(parsed.body)
@@ -78,23 +89,24 @@ export function checkReadingTime(
   const updatedAttributes = {
     ...attributes,
     readingTime,
-    // readingEase,
+    fkglResult: fkglResult.fkgl,
   }
 
   let yamlFrontMatter = ""
   try {
     yamlFrontMatter = yaml.dump(updatedAttributes).trim()
   } catch {
+    Console.error("Error dumping YAML front matter")
     return {
       newMarkdown: "",
       exceedsThreshold: false,
       minutes: 0,
       body: "",
+      fkglResult,
       // readingEase: 0,
     }
   }
 
-  // Reconstruct the markdown with the front matter
   const newMarkdown = `---\n${yamlFrontMatter}\n---\n\n${parsed.body}`
 
   return {
@@ -102,7 +114,7 @@ export function checkReadingTime(
     exceedsThreshold: readingTime.minutes > maxMinutes,
     minutes: readingTime.minutes,
     body: parsed.body,
-    // readingEase: 0,
+    fkglResult,
   }
 }
 
@@ -260,27 +272,17 @@ export function getContentIndex() {
 // }
 
 export function extractTextFromMarkdown(mdContent: string): string {
-  let content = mdContent.replace(/!\[.*?]\(.*?\)/g, "")
-  content = content.replace(/\[.*?]\(.*?\)/g, "")
-  content = content.replace(/`.*?`/g, "")
-  content = content.replace(/```[\S\s]*?```/g, "")
-
-  return content.trim()
+  return mdContent
+    .replace(/!\[.*?]\(.*?\)/g, "") // Remove images
+    .replace(/\[.*?]\(.*?\)/g, "") // Remove links
+    .replace(/(```[\S\s]*?```|`.*?`)/g, "") // Remove inline & block code
+    .replace(/^#.*$/gm, "") // Remove headings
+    .replace(/(\*{1,2}|_{1,2})/g, "") // Remove bold/italic markers
+    .replace(/>\s?/g, "") // Remove blockquotes
+    .replace(/[*-]\s+/g, "") // Remove bullets from lists
+    .trim()
 }
 
-// export const estimateReadingEase = async (text: string): Promise<number> => {
-//   const cleanedText = extractTextFromMarkdown(text)
-//   // @ts-ignore
-//   const rs = (await import("text-readability")).default;
-//   // return fleschKincaidReadingEase(cleanedText)
-//   // const score = readability(cleanedText)
-//   // console.log(score)
-//   // return score.fleschKincaid ?? 0
-//   const score = rs.fleschReadingEase(cleanedText)
-//   console.log(score, "SCORE FLESCH READING EASE")
-//   return score
-// }
-
 const cleanReadme = (readme: string) => {
   // Replace <text> and </text> with nothing
   return readme.replace(/<text>/g, "").replace(/<\/text>/g, "")
@@ -299,3 +301,121 @@ export const saveTranslatedReadme = async (
   )
   fs.writeFileSync(readmePath, cleanReadme(readme))
 }
+
+/**
+ * Extracts paragraphs from a Markdown string.
+ * @param markdownText The input Markdown string.
+ * @returns An array of paragraph contents.
+ */
+export function extractParagraphs(markdownText: string): string[] {
+  const md = new MarkdownIt()
+  const tokens = md.parse(markdownText, {})
+  const paragraphs: string[] = []
+
+  for (let i = 0; i < tokens.length; i++) {
+    if (
+      tokens[i].type === "paragraph_open" &&
+      tokens[i + 1]?.type === "inline"
+    ) {
+      paragraphs.push(tokens[i + 1].content)
+    }
+  }
+
+  return paragraphs
+}
+
+/**
+ * Splits a paragraph into words and separates each word into syllables.
+ * @param paragraph The input paragraph.
+ * @returns An array of words, each split into syllables.
+ */
+export function splitIntoSyllables(paragraph: string): string[] {
+  const words = paragraph.split(/\s+/)
+  const syllables: string[] = []
+
+  for (const word of words) {
+    syllables.push(...splitWordIntoSyllables(word))
+  }
+
+  return syllables
+}
+
+/**
+ * Splits a word into its syllables using a basic estimation.
+ * @param word The word to split.
+ * @returns An array of syllables.
+ */
+export function splitWordIntoSyllables(word: string): string[] {
+  const syllableCount = syllable(word)
+
+  // Simple heuristic: Split word into equal parts (not perfect, better with a dictionary-based approach)
+  if (syllableCount <= 1) 
+return [word]
+
+  const approxLength = Math.ceil(word.length / syllableCount)
+  const syllables: string[] = []
+  for (let i = 0; i < word.length; i += approxLength) {
+    // eslint-disable-next-line
+    syllables.push(word.substring(i, i + approxLength))
+  }
+
+  return syllables
+}
+
+/**
+ * Extracts words from a given paragraph.
+ * @param paragraph The input text.
+ * @returns An array of words.
+ */
+export function extractWords(paragraph: string): string[] {
+  const words = paragraph.match(/\b\w+\b/g) // Match words using regex
+  return words ? words : [] // Return words or an empty array if none found
+}
+
+/**
+ * Calculates the Flesch-Kincaid Grade Level (FKGL) for a given text.
+ * @param text The input paragraph.
+ * @returns The FKGL score.
+ */
+export function fleschKincaidGrade(text: string): TFKGLResult {
+  const processableText = extractTextFromMarkdown(text)
+  const words = extractWords(processableText)
+  const numWords = words.length
+  const numSentences = countSentences(processableText)
+  const numSyllables = words.reduce((total, word) => total + syllable(word), 0)
+
+  if (numWords === 0 || numSentences === 0) {
+    return {
+      text,
+      fkgl: 0,
+    }
+  }
+   
+  const fkgl =
+    // eslint-disable-next-line
+    0.39 * (numWords / numSentences) + 11.8 * (numSyllables / numWords) - 15.59
+
+  return {
+    text,
+    fkgl: parseFloat(fkgl.toFixed(2)),
+  }
+}
+
+/**
+ * Counts the number of sentences in a given text.
+ * @param text The input paragraph.
+ * @returns The total number of sentences.
+ */
+export function countSentences(text: string): number {
+  const sentences = text
+    .split(/[!.?]+/)
+    .filter(sentence => sentence.trim().length > 0)
+  return sentences.length
+}
+
+export function howManyDifficultParagraphs(
+  paragraphs: TFKGLResult[],
+  maxFKGL: number
+): number {
+  return paragraphs.filter(paragraph => paragraph.fkgl > maxFKGL).length
+}