@learnpack/learnpack 5.0.27 → 5.0.29

package/src/managers/server/routes.ts

@@ -279,9 +279,7 @@ throw new Error("File not found: " + filePath)
         TelemetryManager.registerStepEvent(exercise.position, "open_step", {})
       }
 
-      if (configObject.config?.editor.agent === "os") {
-        eventManager.enqueue(dispatcher.events.START_EXERCISE, exercise)
-      } else {
+      if (configObject.config?.editor.agent !== "os") {
         dispatcher.enqueue(dispatcher.events.START_EXERCISE, req.params.slug)
       }
 

package/src/managers/session.ts

@@ -167,6 +167,17 @@ const Session: ISession = {
     this.token = null
     Console.success("You have logged out")
   },
+  breakToken: async function () {
+    const payload = await this.getPayload()
+    if (payload) {
+      this.token = "asdasdasdasd"
+      await storage.setItem("bc-payload", {
+        ...payload,
+        token: "asdasdsad",
+      })
+      Console.success("Token broken successfully")
+    }
+  },
 }
 
 export default Session

package/src/models/session.ts

@@ -35,4 +35,5 @@ export interface ISession {
   sync: () => Promise<void>
   start: ({ token, payload }: IStartProps) => Promise<void>
   destroy: () => Promise<void>
+  breakToken: () => Promise<void>
 }

package/src/utils/api.ts

@@ -79,13 +79,12 @@ const login = async (identification: string, password: string) => {
     await cli.wait(1000)
     const url = `${HOST}/v1/auth/login/`
 
-    const data = await fetch(url, {
-      body: JSON.stringify({
-        email: identification,
-        password: password,
-      }),
-      method: "post",
+    const res = await axios.post(url, {
+      email: identification,
+      password: password,
     })
+    const data = res.data
+
     cli.action.stop("ready")
     let rigoPayload = null
     try {
@@ -320,7 +319,7 @@ export const countConsumables = (
   return consumable ? consumable.balance.unit : 0
 }
 
-export const getConsumables = async (
+export const getConsumable = async (
   token: string,
   consumableSlug: TConsumableSlug = "ai-generation"
 ): Promise<any> => {
@@ -333,18 +332,65 @@ export const getConsumables = async (
   try {
     const response = await axios.get(url, { headers })
 
-    const ai_tutorial_generation = countConsumables(
-      response.data,
-      consumableSlug
-    )
+    const count = countConsumables(response.data, consumableSlug)
 
-    return { ai_tutorial_generation }
+    return { count }
   } catch (error) {
     console.error("Error fetching consumables:", error)
     throw error
   }
 }
 
+export interface TAcademy {
+  id: number
+  name: string
+  slug: string
+  timezone: string
+}
+
+export const listUserAcademies = async (
+  breathecodeToken: string
+): Promise<TAcademy[]> => {
+  const url = "https://breathecode.herokuapp.com/v1/auth/user/me"
+
+  try {
+    const response = await axios.get(url, {
+      headers: {
+        Authorization: `Token ${breathecodeToken}`,
+      },
+    })
+
+    const data = response.data
+
+    const academiesMap = new Map<number, TAcademy>()
+    for (const role of data.roles) {
+      const academy = role.academy
+      if (!academiesMap.has(academy.id)) {
+        academiesMap.set(academy.id, academy)
+      }
+    }
+
+    return [...academiesMap.values()]
+  } catch (error) {
+    console.error("Failed to fetch user academies:", error)
+    return []
+  }
+}
+
+export const validateToken = async (token: string) => {
+  const url = "https://breathecode.herokuapp.com/v1/auth/user/me"
+  const headers = {
+    Authorization: `Token ${token}`,
+  }
+
+  try {
+    const response = await axios.get(url, { headers })
+    return response.data
+  } catch {
+    return false
+  }
+}
+
 export default {
   login,
   publish,
@@ -354,4 +400,6 @@ export default {
   getAllPackages,
   sendBatchTelemetry,
   sendStreamTelemetry,
+  listUserAcademies,
+  validateToken,
 }

package/src/utils/creatorUtilities.ts

@@ -1,6 +1,11 @@
 // eslint-disable-next-line
 const frontMatter = require("front-matter")
 import * as path from "path"
+import * as fs from "fs"
+import { homedir } from "os"
+import { join } from "path"
+import { exec } from "child_process"
+import { promisify } from "util"
 
 import * as yaml from "js-yaml"
 
@@ -49,10 +54,18 @@ export type PackageInfo = {
 
 export function checkReadingTime(
   markdown: string,
-  wordsPerMinute = 150
-): { newMarkdown: string; exceedsThreshold: boolean } {
+  wordsPerMinute = 200,
+  maxMinutes = 1
+): {
+  newMarkdown: string
+  exceedsThreshold: boolean
+  minutes: number
+  body: string
+} {
   const parsed = frontMatter(markdown)
+
   const readingTime = estimateReadingTime(parsed.body, wordsPerMinute)
+
   let attributes = parsed.attributes ? parsed.attributes : {}
 
   if (typeof parsed.attributes !== "object") {
@@ -64,15 +77,26 @@ export function checkReadingTime(
     readingTime,
   }
 
-  // Convert the front matter back to a proper YAML string
-  const yamlFrontMatter = yaml.dump(updatedAttributes).trim()
+  let yamlFrontMatter = ""
+  try {
+    yamlFrontMatter = yaml.dump(updatedAttributes).trim()
+  } catch {
+    return {
+      newMarkdown: "",
+      exceedsThreshold: false,
+      minutes: 0,
+      body: "",
+    }
+  }
 
   // Reconstruct the markdown with the front matter
   const newMarkdown = `---\n${yamlFrontMatter}\n---\n\n${parsed.body}`
 
   return {
     newMarkdown,
-    exceedsThreshold: readingTime.minutes > wordsPerMinute,
+    exceedsThreshold: readingTime.minutes > maxMinutes,
+    minutes: readingTime.minutes,
+    body: parsed.body,
   }
 }
 
@@ -130,8 +154,8 @@ export function getFilenameFromUrl(url: string) {
 export const makePackageInfo = (choices: any) => {
   const packageInfo = {
     grading: choices.grading,
-    difficulty: choices.difficulty,
-    duration: parseInt(choices.duration),
+    difficulty: "beginner",
+    duration: 5,
     description: {
       us: choices.description,
     },
@@ -145,3 +169,73 @@ export const makePackageInfo = (choices: any) => {
   }
   return packageInfo
 }
+
+export function estimateDuration(listOfSteps: string[]): number {
+  let duration = 0
+
+  for (const step of listOfSteps) {
+    if (step.includes("[READ:")) {
+      duration += 1
+    } else if (step.includes("[QUIZ:")) {
+      duration += 2
+    } else if (step.includes("[CODE:")) {
+      duration += 3
+    }
+  }
+
+  return duration
+}
+
+const writeFilePromise = promisify(fs.writeFile)
+const execPromise = promisify(exec)
+
+const example_content = `
+00.1 - Introduction to AI [READ: Small introduction to important concepts such as AI, machine learning, and their applications]
+01.1 - Introduction to Machine Learning [READ: Small introduction to important concepts such as AI, machine learning, and their applications]
+01.2 - Introduction to Deep Learning [QUIZ: Small introduction to important concepts such as AI, machine learning, and their applications]
+02.1 - Test your knowledge [CODE: Code problem to solve]
+`
+
+export async function createFileOnDesktop() {
+  try {
+    const desktopPath = join(homedir(), "Desktop")
+    const filePath = join(desktopPath, "content_index.txt")
+
+    const content = example_content.trim()
+
+    await writeFilePromise(filePath, content)
+    console.log(`File created successfully at: ${filePath}`)
+
+    await openFile(filePath)
+  } catch (error) {
+    console.error("Error:", error)
+  }
+}
+
+async function openFile(filePath: string) {
+  const platform = process.platform
+  let command
+
+  if (platform === "win32") {
+    command = `start "" "${filePath}"`
+  } else if (platform === "darwin") {
+    command = `open "${filePath}"`
+  } else {
+    command = `xdg-open "${filePath}"`
+  }
+
+  try {
+    await execPromise(command)
+    console.log("File opened successfully.")
+  } catch (error) {
+    console.error("Error opening the file:", error)
+  }
+}
+
+export function getContentIndex() {
+  const desktopPath = join(homedir(), "Desktop")
+  const filePath = join(desktopPath, "content_index.txt")
+
+  const content = fs.readFileSync(filePath, "utf8")
+  return content
+}

package/src/utils/rigoActions.ts

@@ -293,3 +293,33 @@ export async function createPreviewReadme(
   })
   fs.writeFileSync(path.join(tutorialDir, readmeFilename), readmeContent.answer)
 }
+
+// {"lesson": "The text of the lesson", "number_of_words": "Words lenght of the lesson", "expected_number_words": "The expected number of words"}
+
+type TReduceReadmeInputs = {
+  lesson: string
+  number_of_words: string
+  expected_number_words: string
+}
+export async function reduceReadme(
+  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.debug(error)
+    return null
+  }
+}