@learnpack/learnpack 5.0.148 → 5.0.152

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

@@ -1,418 +1,62 @@
+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,
       },
       {
         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
-}

package/src/creatorDist/assets/{index-DUPYM87B.css → index-CztA582_.css}

@@ -395,9 +395,6 @@
   .top-2 {
     top: calc(var(--spacing) * 2);
   }
-  .right-0 {
-    right: calc(var(--spacing) * 0);
-  }
   .right-2 {
     right: calc(var(--spacing) * 2);
   }
@@ -525,18 +522,12 @@
   .ml-auto {
     margin-left: auto;
   }
-  .block {
-    display: block;
-  }
   .flex {
     display: flex;
   }
   .hidden {
     display: none;
   }
-  .inline {
-    display: inline;
-  }
   .inline-block {
     display: inline-block;
   }
@@ -718,9 +709,6 @@
   .gap-3 {
     gap: calc(var(--spacing) * 3);
   }
-  .gap-4 {
-    gap: calc(var(--spacing) * 4);
-  }
   :where(.space-y-2 > :not(:last-child)) {
     --tw-space-y-reverse: 0;
     margin-block-start: calc(