@learnpack/learnpack 5.0.66 → 5.0.68

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

@@ -0,0 +1,136 @@
+import { Lesson } from "../components/LessonItem"
+import { eventBus } from "./eventBus"
+import { uploadFileToBucket } from "./lib"
+import { makeReadmeReadable, readmeCreator, checkReadability } from "./rigo"
+import { FormState } from "./store"
+
+export const slugify = (text: string) => {
+  return text
+    .toLowerCase()
+    .replace(/ /g, "-")
+    .replace(/[^\w.-]+/g, "")
+}
+
+export const createLearnJson = (courseInfo: FormState) => {
+  const learnJson = {
+    slug: slugify(courseInfo.title || randomUUID()),
+    title: {
+      us: courseInfo.title,
+    },
+    description: {
+      us: courseInfo.description,
+    },
+    grading: "isolated",
+  }
+  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,
+    })
+
+    // console.log("REDUCED README START", reducedReadme, "REDUCED README END")
+
+    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"
+  await uploadFileToBucket(
+    readability.newMarkdown,
+    `${exercisesDir}/${slugify(
+      exercise.id + "-" + exercise.title
+    )}/${readmeFilename}`
+  )
+
+  if (exercise.type.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
+    // )
+  }
+
+  //   toast.success("Lesson generated successfully", { id: tid })
+  return readability.newMarkdown
+}
+
+export const randomUUID = () => {
+  return Math.random().toString(36).substring(2, 15)
+}

package/src/creator/src/utils/eventBus.ts

@@ -0,0 +1,2 @@
+import mitt from "mitt"
+export const eventBus = mitt()

package/src/creator/src/utils/lib.ts

@@ -1,4 +1,5 @@
 import axios from "axios"
+import { BREATHECODE_HOST } from "./constants"
 
 type ParsedLesson = {
   id: string
@@ -34,3 +35,88 @@ export const uploadFileToBucket = async (content: string, path: string) => {
   })
   return response.data
 }
+
+export const checkParams = () => {
+  const urlParams = new URLSearchParams(window.location.search)
+  const token = urlParams.get("token")
+  return { token }
+}
+
+export async function getConsumables(token: string): Promise<any> {
+  const url = `${BREATHECODE_HOST}/v1/payments/me/service/consumable?virtual=true`
+
+  const headers = {
+    Authorization: `Token ${token}`,
+  }
+
+  try {
+    const response = await axios.get(url, { headers })
+    return response.data
+  } catch (error) {
+    console.error("Error fetching consumables:", error)
+    throw error
+  }
+}
+
+type ConsumableSlug =
+  | "ai-conversation-message"
+  | "ai-compilation"
+  | "ai-generation"
+  | "ai-course-generation"
+
+export async function useConsumableCall(
+  breathecodeToken: string,
+  consumableSlug: ConsumableSlug = "ai-conversation-message"
+): Promise<boolean> {
+  const url = `${BREATHECODE_HOST}/v1/payments/me/service/${consumableSlug}/consumptionsession`
+
+  const headers = {
+    Authorization: `Token ${breathecodeToken}`,
+  }
+
+  try {
+    const response = await axios.put(url, {}, { headers })
+
+    if (response.status >= 200 && response.status < 300) {
+      console.log(response.data)
+      console.log(`Successfully consumed ${consumableSlug}`)
+      return true
+    } else {
+      console.error(`Request failed with status code: ${response.status}`)
+      console.error(`Response: ${response.data}`)
+      return false
+    }
+  } catch (error) {
+    console.error(`Error consuming ${consumableSlug}:`, error)
+    return false
+  }
+}
+
+type ConsumableItem = {
+  id: number
+  how_many: number
+  unit_type: string
+  valid_until: string | null
+}
+
+type VoidEntry = {
+  id: number
+  slug: string
+  balance: { unit: number }
+  items: ConsumableItem[]
+}
+
+export const parseConsumables = (
+  voids: VoidEntry[]
+): Record<string, number> => {
+  const result: Record<string, number> = {}
+
+  voids.forEach((entry) => {
+    const maxHowMany = entry.items.length
+      ? Math.max(...entry.items.map((item) => item.how_many))
+      : 0
+    result[entry.slug] = maxHowMany
+  })
+
+  return result
+}

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

@@ -1,6 +1,6 @@
 import { create } from "zustand"
 import { persist } from "zustand/middleware"
-import { Lesson } from "../components/SyllabusEditor"
+import { Lesson } from "../components/LessonItem"
 
 export type FormState = {
   description: string
@@ -21,6 +21,14 @@ type Auth = {
 type Syllabus = {
   lessons: Lesson[]
   courseInfo: FormState
+  uploadedFiles: {
+    name: string
+    text: string
+  }[]
+}
+
+type Consumables = {
+  [key: string]: number
 }
 
 type Store = {
@@ -30,6 +38,8 @@ type Store = {
   syllabus: Syllabus
   setSyllabus: (syllabus: Partial<Syllabus>) => void
   setFormState: (formState: Partial<FormState>) => void
+  consumables: Consumables
+  setConsumables: (consumables: Partial<Consumables>) => void
 }
 
 const useStore = create<Store>()(
@@ -64,7 +74,21 @@ const useStore = create<Store>()(
           currentStep: 0,
           title: "",
         },
+        uploadedFiles: [],
       },
+      consumables: {},
+      setConsumables: (consumables: Partial<Consumables>) =>
+        set((state) => {
+          const sanitized: Consumables = Object.fromEntries(
+            Object.entries(consumables).map(([k, v]) => [k, v ?? 0])
+          )
+          return {
+            consumables: {
+              ...state.consumables,
+              ...sanitized,
+            },
+          }
+        }),
       setSyllabus: (syllabus: Partial<Syllabus>) =>
         set((state) => ({ syllabus: { ...state.syllabus, ...syllabus } })),
       setAuth: (auth: Auth) => set({ auth }),