@learnpack/learnpack 5.0.146 → 5.0.150

package/src/creator/src/components/syllabus/Sidebar.tsx

@@ -39,34 +39,34 @@ export const Sidebar = ({
   return (
     <>
       {!isOpen && (
-        <>
-          <div className="fixed bottom-5 left-2 z-50 lg:hidden">
-            {showBubble && (
-              <div
-                className={`flex flex-row gap-3 cloudy bg-white rounded-md p-2 shadow-md bg-learnpack-blue duration-500 border-2 border-blue-600`}
-              >
-                <span>Chat with me to update the course content</span>
-                <button
-                  className=" text-red-500 cursor-pointer bg-learnpack-blue p-2 rounded-md"
-                  onClick={() => setShowBubble(false)}
-                >
-                  {SVGS.redClose}
-                </button>
-              </div>
-            )}
-            <button
-              className="p-1 shadow-md cursor-pointer p-2 w-15 h-15 flex items-center justify-center bg-blue-600 rounded-[50%] fluid-svg"
-              onClick={() => setIsOpen(true)}
+        <div className="fixed bottom-5 left-2 z-30 lg:hidden">
+          {showBubble && (
+            <div
+              className={`flex flex-row gap-3 cloudy bg-white rounded-md p-2 shadow-md bg-learnpack-blue duration-500 border-2 border-blue-600 mb-4`}
             >
-              {SVGS.rigoSoftBlue}
-            </button>
-          </div>
-        </>
+              <span className="w-[280px]">
+                Chat with me to update the course content
+              </span>
+              <button
+                className=" text-red-500 cursor-pointer bg-learnpack-blue p-2 rounded-md"
+                onClick={() => setShowBubble(false)}
+              >
+                {SVGS.redClose}
+              </button>
+            </div>
+          )}
+          <button
+            className="p-1 shadow-md cursor-pointer p-2 w-15 h-15 flex items-center justify-center bg-blue-600 rounded-[50%] fluid-svg"
+            onClick={() => setIsOpen(true)}
+          >
+            {SVGS.rigoSoftBlue}
+          </button>
+        </div>
       )}
 
       <div
         ref={sidebarRef}
-        className={`fixed z-40 top-0 left-0 h-full w-4/5 max-w-sm bg-learnpack-blue text-sm text-gray-700 border-r border-C8DBFC overflow-y-auto scrollbar-hide p-6 transition-transform duration-300 ease-in-out lg:relative lg:transform-none lg:w-1/3 ${
+        className={`fixed z-30 top-0 left-0 h-full w-4/5 max-w-sm bg-learnpack-blue text-sm text-gray-700 border-r border-C8DBFC overflow-y-auto scrollbar-hide p-6 transition-transform duration-300 ease-in-out lg:relative lg:transform-none lg:w-1/3 ${
           isOpen ? "translate-x-0" : "-translate-x-full lg:translate-x-0"
         }`}
       >

package/src/creator/src/components/syllabus/SyllabusEditor.tsx

@@ -146,7 +146,10 @@ const SyllabusEditor: React.FC = () => {
       setShowLoginModal(true)
       return
     }
-    const success = await useConsumableCall(auth.bcToken, "ai-generation")
+    const success = await useConsumableCall(
+      auth.bcToken,
+      "ai-course-generation"
+    )
     if (!success) {
       toast.error("You don't have enough credits to generate a course!")
       return

package/src/creator/src/index.css

@@ -35,11 +35,6 @@ body {
   background-color: #f4f9fe;
 }
 
-h1 {
-  font-size: 3.2em;
-  line-height: 1.1;
-}
-
 .bg-learnpack-blue {
   background-color: var(--soft-blue);
 }

package/src/creator/src/utils/creatorUtils.ts

@@ -1,18 +1,5 @@
-import { Lesson } from "../components/LessonItem"
 import { eventBus } from "./eventBus"
-import {
-  generateImage,
-  getFilenameFromUrl,
-  uploadFileToBucket,
-  uploadImageToBucket,
-} from "./lib"
-import {
-  makeReadmeReadable,
-  readmeCreator,
-  checkReadability,
-  createCodeFile,
-} from "./rigo"
-import { FormState } from "./store"
+import { generateImage, getFilenameFromUrl, uploadImageToBucket } from "./lib"
 
 export const slugify = (text: string) => {
   return text
@@ -21,133 +8,6 @@ export const slugify = (text: string) => {
     .replace(/[^\w.-]+/g, "")
 }
 
-export const createLearnJson = (courseInfo: FormState) => {
-  console.log("courseInfo to create learn json", courseInfo)
-
-  const learnJson = {
-    slug: slugify(courseInfo.title as string),
-    title: {
-      us: courseInfo.title,
-    },
-    technologies: courseInfo.technologies || [],
-    difficulty: "beginner",
-    description: {
-      us: courseInfo.description,
-    },
-    grading: "isolated",
-    telemetry: {
-      batch: "https://breathecode.herokuapp.com/v1/assignment/me/telemetry",
-    },
-    preview: "preview.png",
-  }
-  return learnJson
-}
-
-const PARAMS = {
-  expected_grade_level: "6",
-  max_fkgl: 8,
-  max_words: 200,
-  max_rewrite_attempts: 3,
-  max_title_length: 50,
-}
-export async function processExercise(
-  rigoToken: string,
-  steps: Lesson[],
-  packageContext: string,
-  exercise: Lesson,
-  exercisesDir: string
-): Promise<string> {
-  //   const tid = toast.loading("Generating lesson...")
-  setTimeout(() => {
-    eventBus.emit("course-generation", {
-      message: `✍🏻 Generating lesson ${exercise.id} - ${exercise.title}...`,
-    })
-  }, 500)
-  const readme = await readmeCreator(rigoToken, {
-    title: `${exercise.id} - ${exercise.title}`,
-    output_lang: "en",
-    list_of_exercises: JSON.stringify(steps),
-    tutorial_description: packageContext,
-    lesson_description: exercise.description,
-    kind: exercise.type.toLowerCase(),
-  })
-
-  const duration = exercise.duration
-  let attempts = 0
-  let readability = checkReadability(readme.parsed.content, 200, duration || 1)
-
-  while (
-    readability.fkglResult.fkgl > PARAMS.max_fkgl &&
-    attempts < PARAMS.max_rewrite_attempts
-  ) {
-    setTimeout(() => {
-      eventBus.emit("course-generation", {
-        message: `🔄 The lesson ${exercise.id} - ${
-          exercise.title
-        } has a readability score of ${
-          readability.fkglResult.fkgl
-        }. Rewriting it... (Attempt ${attempts + 1})`,
-      })
-    }, 500)
-    // 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++
-  }
-
-  setTimeout(() => {
-    eventBus.emit("course-generation", {
-      message: `✅ After ${attempts} attempts, the lesson ${
-        exercise.title
-      } has a readability score of ${
-        readability.fkglResult.fkgl
-      } using FKGL. And it has ${readability.minutes.toFixed(
-        2
-      )} minutes of reading time.`,
-    })
-  }, 500)
-
-  const readmeFilename = "README.md"
-
-  const targetDir = `${exercisesDir}/${slugify(
-    exercise.id + "-" + exercise.title
-  )}`
-  await uploadFileToBucket(
-    readability.newMarkdown,
-    `${targetDir}/${readmeFilename}`
-  )
-
-  if (exercise.type.toLowerCase() === "code") {
-    eventBus.emit("course-generation", {
-      message: `🔍 Creating code file for ${exercise.title}`,
-    })
-    const codeFile = await createCodeFile(rigoToken, {
-      readme: readability.newMarkdown,
-      tutorial_info: packageContext,
-    })
-    await uploadFileToBucket(
-      codeFile.parsed.content,
-      `${targetDir}/index.${codeFile.parsed.extension.replace(".", "")}`
-    )
-  }
-
-  return readability.newMarkdown
-}
-
 export const randomUUID = () => {
   return Math.random().toString(36).substring(2, 15)
 }

package/src/creator/src/utils/rigo.ts

@@ -1,418 +1,63 @@
+import toast from "react-hot-toast"
 import { RIGOBOT_HOST } from "./constants"
-import axios from "axios"
-import frontMatter from "front-matter"
-import { syllable } from "syllable"
-
-import * as yaml from "js-yaml"
+import axios, { AxiosError } from "axios"
 
 type TInteractiveCreationInputs = {
   courseInfo: string
   prevInteractions: string
 }
+
 export const interactiveCreation = async (
-  // token: string,
   inputs: TInteractiveCreationInputs
-) => {
-  const response = await axios.post(
-    `${RIGOBOT_HOST}/v1/prompting/public/completion/390/`,
-    {
-      inputs: inputs,
-      include_purpose_objective: false,
-      execute_async: false,
-    },
-    {
-      headers: {
-        "Content-Type": "application/json",
-        // Authorization: "Token " + token,
-      },
-    }
-  )
-
-  return response.data
-}
-
-type TCreateReadmeInputs = {
-  title: string
-  output_lang: string
-  list_of_exercises: string
-  tutorial_description: string
-  include_quiz: string
-  lesson_description: string
-}
-
-export const createReadme = async (
-  token: string,
-  inputs: TCreateReadmeInputs
-) => {
+): Promise<any | null> => {
   try {
     const response = await axios.post(
-      `${RIGOBOT_HOST}/v1/prompting/completion/423/`,
+      `${RIGOBOT_HOST}/v1/prompting/public/completion/390/`,
       {
-        inputs,
+        inputs: inputs,
         include_purpose_objective: false,
         execute_async: false,
       },
       {
+        withCredentials: true,
         headers: {
           "Content-Type": "application/json",
-          Authorization: "Token " + token,
         },
       }
     )
-    return response.data
-  } catch (error) {
-    console.error(error)
-    return null
-  }
-}
-
-type TCreateCodingReadmeInputs = {
-  tutorial_description: string
-  list_of_exercises: string
-  output_lang: string
-  title: string
-  lesson_description: string
-}
-export const createCodingReadme = async (
-  token: string,
-  inputs: TCreateCodingReadmeInputs
-) => {
-  const response = await axios.post(
-    `${RIGOBOT_HOST}/v1/prompting/completion/489/`,
-    { inputs, include_purpose_objective: false, execute_async: false },
-    {
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: "Token " + token,
-      },
-    }
-  )
-
-  return response.data
-}
-
-type TReadmeCreatorInputs = {
-  tutorial_description: string
-  list_of_exercises: string
-  output_lang: string
-  title: string
-  lesson_description: string
-  kind: string
-}
-
-export const readmeCreator = async (
-  token: string,
-  inputs: TReadmeCreatorInputs
-) => {
-  if (inputs.kind === "quiz" || inputs.kind === "read") {
-    const createReadmeInputs: TCreateReadmeInputs = {
-      title: inputs.title,
-      output_lang: inputs.output_lang,
-      list_of_exercises: inputs.list_of_exercises,
-      tutorial_description: inputs.tutorial_description,
-      include_quiz: inputs.kind === "quiz" ? "true" : "false",
-      lesson_description: inputs.lesson_description,
-    }
-    return createReadme(token, createReadmeInputs)
-  }
 
-  if (inputs.kind === "code") {
-    return createCodingReadme(token, {
-      title: inputs.title,
-      output_lang: inputs.output_lang,
-      list_of_exercises: inputs.list_of_exercises,
-      tutorial_description: inputs.tutorial_description,
-      lesson_description: inputs.lesson_description,
-    })
-  }
-
-  throw new Error("Invalid kind of lesson")
-}
-
-type TEstimateReadingTimeReturns = {
-  minutes: number
-  words: number
-}
-
-export const estimateReadingTime = (
-  text: string,
-  wordsPerMinute = 150
-): TEstimateReadingTimeReturns => {
-  const words = text.trim().split(/\s+/).length
-  const minutes = words / wordsPerMinute
+    return response.data
+  } catch (error: unknown) {
+    const err = error as AxiosError
 
-  if (minutes < 1) {
-    if (words === 0)
-      return {
-        minutes: 1,
-        words,
-      }
-  } else {
-    return {
-      minutes,
-      words,
+    if (err.response?.status === 403) {
+      toast.error("You've reached the limit. Please log in to continue.")
+    } else {
+      toast.error("Something went wrong while generating the course.")
     }
-  }
 
-  return {
-    minutes: 1,
-    words,
+    return null
   }
 }
 
-type TFKGLResult = {
-  text: string
-  fkgl: number
-}
-
-export function checkReadability(
-  markdown: string,
-  wordsPerMinute = 200,
-  maxMinutes = 1
-): {
-  newMarkdown: string
-  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)
-  let attributes = parsed.attributes ? parsed.attributes : {}
-
-  if (typeof parsed.attributes !== "object") {
-    attributes = {}
-  }
-
-  const updatedAttributes = {
-    ...attributes,
-    readingTime,
-    fkglResult: fkglResult.fkgl,
-  }
-
-  let yamlFrontMatter = ""
+export const isHuman = async (token: string) => {
   try {
-    yamlFrontMatter = yaml.dump(updatedAttributes).trim()
-  } catch {
-    // Console.error("Error dumping YAML front matter")
-    return {
-      newMarkdown: "",
-      exceedsThreshold: false,
-      minutes: 0,
-      body: "",
-      fkglResult,
-      // readingEase: 0,
+    const body = {
+      access_token: token,
     }
-  }
-
-  const newMarkdown = `---\n${yamlFrontMatter}\n---\n\n${parsed.body}`
-
-  return {
-    newMarkdown,
-    exceedsThreshold: readingTime.minutes > maxMinutes,
-    minutes: readingTime.minutes,
-    body: parsed.body,
-    fkglResult,
-  }
-}
-
-export function extractImagesFromMarkdown(markdown: string) {
-  const imageRegex = /!\[([^\]]*)]\(([^)]+)\)/g
-  const images = []
-  let match
-
-  while ((match = imageRegex.exec(markdown)) !== null) {
-    const altText = match[1]
-    const url = match[2]
-    images.push({ alt: altText, url: url })
-  }
-
-  return images
-}
-
-export function estimateDuration(listOfSteps: string[]): number {
-  let duration = 0
-
-  for (const step of listOfSteps) {
-    if (step.includes("[READ:")) {
-      duration += 2
-    } else if (step.includes("[QUIZ:")) {
-      duration += 3
-    } else if (step.includes("[CODE:")) {
-      duration += 5
-    }
-  }
-
-  return duration
-}
-
-export function extractTextFromMarkdown(mdContent: string): string {
-  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()
-}
-
-/**
- * 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
-}
-
-type TReduceReadmeInputs = {
-  lesson: string
-  number_of_words: string
-  expected_number_words: string
-  fkgl_results: string
-  expected_grade_level: string
-}
-export async function makeReadmeReadable(
-  rigoToken: string,
-  inputs: TReduceReadmeInputs
-) {
-  try {
     const response = await axios.post(
-      `${RIGOBOT_HOST}/v1/prompting/completion/588/`,
-      { inputs, include_purpose_objective: false, execute_async: false },
+      `${RIGOBOT_HOST}/v1/auth/verify/humanity`,
+      body,
       {
         headers: {
           "Content-Type": "application/json",
-          Authorization: "Token " + rigoToken,
         },
       }
     )
 
-    return response.data
+    return response.status === 200
   } catch (error) {
     console.error(error)
-    // Console.debug(error)
-    return null
+    return false
   }
 }
-
-type TCreateCodeFileInputs = {
-  readme: string
-  tutorial_info: string
-}
-
-export const createCodeFile = async (
-  token: string,
-  inputs: TCreateCodeFileInputs
-) => {
-  const response = await axios.post(
-    `${RIGOBOT_HOST}/v1/prompting/completion/456/`,
-    {
-      inputs: inputs,
-      include_purpose_objective: false,
-      execute_async: false,
-    },
-    {
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: "Token " + token,
-      },
-    }
-  )
-
-  return response.data
-}