@learnpack/learnpack 5.0.54 → 5.0.58

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

@@ -0,0 +1,391 @@
+import { RIGOBOT_HOST } from "./constants"
+import axios from "axios"
+import frontMatter from "front-matter"
+import { syllable } from "syllable"
+
+import * as yaml from "js-yaml"
+
+type TInteractiveCreationInputs = {
+  courseInfo: string
+  prevInteractions: string
+}
+export const interactiveCreation = async (
+  token: string,
+  inputs: TInteractiveCreationInputs
+) => {
+  const response = await axios.post(
+    `${RIGOBOT_HOST}/v1/prompting/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
+) => {
+  try {
+    const response = await axios.post(
+      `${RIGOBOT_HOST}/v1/prompting/completion/423/`,
+      {
+        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
+
+  if (minutes < 1) {
+    if (words === 0)
+      return {
+        minutes: 1,
+        words,
+      }
+  } else {
+    return {
+      minutes,
+      words,
+    }
+  }
+
+  return {
+    minutes: 1,
+    words,
+  }
+}
+
+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 = ""
+  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 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 },
+      {
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: "Token " + rigoToken,
+        },
+      }
+    )
+
+    return response.data
+  } catch (error) {
+    console.error(error)
+    // Console.debug(error)
+    return null
+  }
+}

package/src/creator/src/utils/store.ts

@@ -0,0 +1,78 @@
+import { create } from "zustand"
+import { persist } from "zustand/middleware"
+import { Lesson } from "../components/SyllabusEditor"
+
+export type FormState = {
+  description: string
+  duration: number
+  targetAudience: string
+  hasContentIndex: boolean
+  contentIndex: string
+  isCompleted: boolean
+  currentStep: number
+  title?: string
+}
+
+type Auth = {
+  bcToken: string
+  rigoToken: string
+  userId: string
+}
+type Syllabus = {
+  lessons: Lesson[]
+  courseInfo: FormState
+}
+
+type Store = {
+  auth: Auth
+  formState: FormState
+  setAuth: (auth: Auth) => void
+  syllabus: Syllabus
+  setSyllabus: (syllabus: Partial<Syllabus>) => void
+  setFormState: (formState: Partial<FormState>) => void
+}
+
+const useStore = create<Store>()(
+  persist(
+    (set) => ({
+      auth: {
+        bcToken: "",
+        rigoToken: "",
+        userId: "",
+      },
+      formState: {
+        description: "",
+        duration: 0,
+        targetAudience: "",
+        hasContentIndex: false,
+        contentIndex: "",
+        isCompleted: false,
+        currentStep: 0,
+      },
+      setFormState: (formState: Partial<FormState>) =>
+        set((state) => ({ formState: { ...state.formState, ...formState } })),
+
+      syllabus: {
+        lessons: [],
+        courseInfo: {
+          description: "",
+          duration: 0,
+          targetAudience: "",
+          hasContentIndex: false,
+          contentIndex: "",
+          isCompleted: false,
+          currentStep: 0,
+          title: "",
+        },
+      },
+      setSyllabus: (syllabus: Partial<Syllabus>) =>
+        set((state) => ({ syllabus: { ...state.syllabus, ...syllabus } })),
+      setAuth: (auth: Auth) => set({ auth }),
+    }),
+    {
+      name: "syllabus-storage",
+    }
+  )
+)
+
+export default useStore

package/src/creator/src/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />

package/src/creator/tsconfig.app.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "isolatedModules": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+    "jsx": "react-jsx",
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["src"]
+}

package/src/creator/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "files": [],
+  "references": [
+    { "path": "./tsconfig.app.json" },
+    { "path": "./tsconfig.node.json" }
+  ]
+}

package/src/creator/tsconfig.node.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+    "target": "ES2022",
+    "lib": ["ES2023"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "isolatedModules": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["vite.config.ts"]
+}

package/src/creator/vite.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from "vite"
+import react from "@vitejs/plugin-react-swc"
+import tailwindcss from "@tailwindcss/vite"
+
+// https://vite.dev/config/
+export default defineConfig({
+  plugins: [react(), tailwindcss()],
+  base: "/creator/",
+  build: {
+    outDir: "../creatorDist",
+    emptyOutDir: true,
+  },
+})