@learnpack/learnpack 2.1.26 → 2.1.28

package/src/plugin/plugin.ts

@@ -1,5 +1,5 @@
-import * as shell from "shelljs";
-import { IPluginConfig } from "../models/plugin-config";
+import * as shell from "shelljs"
+import { IPluginConfig } from "../models/plugin-config"
 /**
  * Main Plugin Runner, it defines the behavior of a learnpack plugin
  * dividing it in "actions" like: Compile, test, etc.
@@ -7,88 +7,88 @@ import { IPluginConfig } from "../models/plugin-config";
  */
 export default (pluginConfig: IPluginConfig) => {
   return async (args: any) => {
-    const { action, exercise, socket, configuration } = args;
+    const { action, exercise, socket, configuration } = args
 
     if (pluginConfig.language === undefined)
-      throw new Error(`Missing language on the plugin configuration object`);
+      throw new Error(`Missing language on the plugin configuration object`)
 
     if (typeof action !== "string") {
-      throw new TypeError("Missing action property on hook details");
+      throw new TypeError("Missing action property on hook details")
     }
 
     if (!exercise || exercise === undefined) {
-      throw new Error("Missing exercise information");
+      throw new Error("Missing exercise information")
     }
 
     type actionType = "compile" | "test";
 
     // if the action does not exist I don't do anything
     if (pluginConfig[action as actionType] === undefined) {
-      console.log(`Ignoring ${action}`);
-      return () => null;
+      console.log(`Ignoring ${action}`)
+      return () => null
     }
 
     // ignore if the plugin language its not the same as the exercise language
     if (exercise.language !== pluginConfig.language) {
-      return () => null;
+      return () => null
     }
 
     if (!exercise.files || exercise.files.length === 0) {
-      throw new Error(`No files to process`);
+      throw new Error(`No files to process`)
     }
 
     try {
-      const _action = pluginConfig[action as actionType];
+      const _action = pluginConfig[action as actionType]
 
       if (_action === null || typeof _action !== "object")
         throw new Error(
           `The ${pluginConfig.language} ${action} module must export an object configuration`
-        );
+        )
       if (_action.validate === undefined)
         throw new Error(
           `Missing validate method for ${pluginConfig.language} ${action}`
-        );
+        )
       if (_action.run === undefined)
         throw new Error(
           `Missing run method for ${pluginConfig.language} ${action}`
-        );
+        )
       if (_action.dependencies !== undefined) {
         if (!Array.isArray(_action.dependencies))
           throw new Error(
             `${action}.dependencies must be an array of package names`
-          );
+          )
 
         for (const packageName of _action.dependencies) {
           if (!shell.which(packageName)) {
             throw new Error(
               `🚫 You need to have ${packageName} installed to run test the exercises`
-            );
+            )
           }
         }
       }
 
-      const valid = await _action.validate({ exercise, configuration });
+      const valid = await _action.validate({ exercise, configuration })
       if (valid) {
         // look for the command standard implementation and execute it
-        const execute = require("./command/" + action + ".js").default;
+        const execute = require("./command/" + action + ".js").default
         // no matter the command, the response must always be a stdout
         const stdout = await execute({
           ...args,
           action: _action,
           configuration,
-        });
+        })
 
         // Map the action names to socket messaging standards
-        const actionToSuccessMapper = { compile: "compiler", test: "testing" };
+        const actionToSuccessMapper = { compile: "compiler", test: "testing" }
 
-        socket.success(actionToSuccessMapper[action as actionType], stdout);
-        return stdout;
+        socket.success(actionToSuccessMapper[action as actionType], stdout)
+        return stdout
       }
     } catch (error: any) {
       if (error.type === undefined) 
-socket.fatal(error);
+socket.fatal(error)
       else 
-socket.error(error.type, error.stdout);
+socket.error(error.type, error.stdout)
     }
-  };
-};
+  }
+}

package/src/plugin/utils.ts

@@ -1,74 +1,74 @@
-import * as chalk from "chalk";
+import * as chalk from "chalk"
 
 const getMatches = (reg: RegExp, content: string) => {
-  const inputs = [];
-  let m;
+  const inputs = []
+  let m
   while ((m = reg.exec(content)) !== null) {
     // This is necessary to avoid infinite loops with zero-width matches
     if (m.index === reg.lastIndex) 
-reg.lastIndex++;
+reg.lastIndex++
 
     // The result can be accessed through the `m`-variable.
-    inputs.push(m[1] || null);
+    inputs.push(m[1] || null)
   }
 
-  return inputs;
-};
+  return inputs
+}
 
 const cleanStdout = (buffer: string, inputs: string[]) => {
   if (Array.isArray(inputs))
     for (let i = 0; i < inputs.length; i++)
       if (inputs[i]) 
-buffer = buffer.replace(inputs[i], "");
+buffer = buffer.replace(inputs[i], "")
 
-  return buffer;
-};
+  return buffer
+}
 
 const indent = (string: string, options: any, count = 1) => {
   options = {
     indent: " ",
     includeEmptyLines: false,
     ...options,
-  };
+  }
 
   if (typeof string !== "string") {
     throw new TypeError(
       `Expected \`input\` to be a \`string\`, got \`${typeof string}\``
-    );
+    )
   }
 
   if (typeof count !== "number") {
     throw new TypeError(
       `Expected \`count\` to be a \`number\`, got \`${typeof count}\``
-    );
+    )
   }
 
   if (count < 0) {
     throw new RangeError(
       `Expected \`count\` to be at least 0, got \`${count}\``
-    );
+    )
   }
 
   if (typeof options.indent !== "string") {
     throw new TypeError(
       `Expected \`options.indent\` to be a \`string\`, got \`${typeof options.indent}\``
-    );
+    )
   }
 
   if (count === 0) {
-    return string;
+    return string
   }
 
-  const regex = options.includeEmptyLines ? /^/gm : /^(?!\s*$)/gm;
+  const regex = options.includeEmptyLines ? /^/gm : /^(?!\s*$)/gm
 
-  return string.replace(regex, options.indent.repeat(count));
-};
+  return string.replace(regex, options.indent.repeat(count))
+}
 
 const Console = {
   // _debug: true,
   _debug: process.env.DEBUG === "true",
   startDebug: function () {
-    this._debug = true;
+    this._debug = true
   },
   log: (msg: string, ...args: any[]) => console.log(chalk.gray(msg), ...args),
   error: (msg: string, ...args: any[]) =>
@@ -80,8 +80,8 @@ const Console = {
   help: (msg: string) =>
     console.log(`${chalk.white.bold("⚠ help:")} ${chalk.white(msg)}`),
   debug(...args: any[]) {
-    this._debug && console.log(chalk.magentaBright(`⚠ debug: `), args);
+    this._debug && console.log(chalk.magentaBright(`⚠ debug: `), args)
   },
-};
+}
 
-export default { getMatches, cleanStdout, indent, Console };
+export default { getMatches, cleanStdout, indent, Console }

package/src/utils/BaseCommand.ts

@@ -1,42 +1,42 @@
-import { Command } from "@oclif/command";
-import Console from "./console";
-import { createInterface } from "readline";
+import { Command } from "@oclif/command"
+import Console from "./console"
+import { createInterface } from "readline"
 // import SessionManager from '../managers/session'
 
 class BaseCommand extends Command {
   async catch(err: any) {
-    Console.debug("COMMAND CATCH", err);
+    Console.debug("COMMAND CATCH", err)
 
-    throw err;
+    throw err
   }
 
   async init() {
-    const { flags, args } = this.parse(BaseCommand);
-    Console.debug("COMMAND INIT");
-    Console.debug("These are your flags: ", flags);
-    Console.debug("These are your args: ", args);
+    const { flags, args } = this.parse(BaseCommand)
+    Console.debug("COMMAND INIT")
+    Console.debug("These are your flags: ", flags)
+    Console.debug("These are your args: ", args)
 
     // quick fix for listening to the process termination on windows
     if (process.platform === "win32") {
       const rl = createInterface({
         input: process.stdin,
         output: process.stdout,
-      });
+      })
 
       rl.on("SIGINT", function () {
         // process.emit('SIGINT')
         // process.emit('SIGINT')
-      });
+      })
     }
 
     process.on("SIGINT", function () {
-      Console.debug("Terminated (SIGINT)");
-      process.exit();
-    });
+      Console.debug("Terminated (SIGINT)")
+      process.exit()
+    })
   }
 
   async finally() {
-    Console.debug("COMMAND FINALLY");
+    Console.debug("COMMAND FINALLY")
     // called after run and catch regardless of whether or not the command errored
   }
 
@@ -45,4 +45,4 @@ class BaseCommand extends Command {
   }
 }
 
-export default BaseCommand;
+export default BaseCommand

package/src/utils/api.ts

@@ -1,7 +1,8 @@
-import Console from "../utils/console";
-import * as storage from "node-persist";
-import cli from "cli-ux";
-const HOST = "https://learnpack.herokuapp.com";
+import Console from "../utils/console"
+import * as storage from "node-persist"
+import cli from "cli-ux"
+const HOST = "https://breathecode.herokuapp.com"
+const RIGOBOT_HOST = "https://rigobot.herokuapp.com"
 
 // eslint-disable-next-line
 const _fetch = require("node-fetch");
@@ -18,65 +19,107 @@ interface IOptions {
 }
 
 const fetch = async (url: string, options: IOptions = {}) => {
-  const headers: IHeaders = { "Content-Type": "application/json" };
-  let session = null;
+  const headers: IHeaders = { "Content-Type": "application/json" }
+  Console.log(`Fetching ${url}`)
+  let session = null
   try {
-    session = await storage.getItem("bc-payload");
+    session = await storage.getItem("bc-payload")
     if (session.token && session.token !== "" && !url.includes("/token"))
-      headers.Authorization = "Token " + session.token;
+      headers.Authorization = "Token " + session.token
   } catch {}
 
   try {
     const resp = await _fetch(url, {
       ...options,
       headers: { ...headers, ...options.headers },
-    } as any);
+    } as any)
 
     if (resp.status >= 200 && resp.status < 300) 
-return await resp.json();
+return await resp.json()
     if (resp.status === 401)
-      throw APIError("Invalid authentication credentials", 401);
+      throw APIError("Invalid authentication credentials", 401)
     else if (resp.status === 404) 
-throw APIError("Package not found", 404);
+throw APIError("Package not found", 404)
     else if (resp.status >= 500)
-      throw APIError("Impossible to connect with the server", 500);
+      throw APIError("Impossible to connect with the server", 500)
     else if (resp.status >= 400) {
-      const error = await resp.json();
+      const error = await resp.json()
       if (error.detail || error.error) {
-        throw APIError(error.detail || error.error);
+        throw APIError(error.detail || error.error)
       } else if (error.nonFieldErrors) {
-        throw APIError(error.nonFieldErrors[0], error);
+        throw APIError(error.nonFieldErrors[0], error)
       } else if (typeof error === "object") {
         if (Object.keys(error).length > 0) {
-          const key = error[Object.keys(error)[0]];
-          throw APIError(`${key}: ${error[key][0]}`, error);
+          const key = error[Object.keys(error)[0]]
+          throw APIError(`${key}: ${error[key][0]}`, error)
         }
       } else {
-        throw APIError("Uknown error");
+        throw APIError("Uknown error")
       }
     } else 
-throw APIError("Uknown error");
+throw APIError("Uknown error")
   } catch (error) {
-    Console.error((error as TypeError).message);
-    throw error;
+    Console.error((error as TypeError).message)
+    throw error
   }
-};
+}
 
 const login = async (identification: string, password: string) => {
   try {
-    cli.action.start("Looking for credentials...");
-    await cli.wait(1000);
-    const data = await fetch(`${HOST}/v1/auth/token/`, {
-      body: JSON.stringify({ identification, password }),
+    cli.action.start(`Looking for credentials with ${identification}`)
+    await cli.wait(1000)
+    const url = `${HOST}/v1/auth/login/`
+    // Console.log(url);
+    const data = await fetch(url, {
+      body: JSON.stringify({
+        email: identification,
+        password: password,
+      }),
       method: "post",
-    });
-    cli.action.stop("ready");
-    return data;
+    })
+    cli.action.stop("ready")
+    const payload = await loginRigo(data.token)
+
+    return { ...data, rigobot: payload }
   } catch (error) {
-    Console.error((error as TypeError).message);
-    Console.debug(error);
+    cli.action.stop("error")
+    Console.error((error as TypeError).message)
+    Console.debug(error)
+  }
+}
+
+const loginRigo = async (token: string) => {
+  const rigoUrl = `${RIGOBOT_HOST}/v1/auth/me/token?breathecode_token=${token}`
+  const rigoResp = await _fetch(rigoUrl)
+  const rigobotJson = await rigoResp.json()
+  return rigobotJson
+}
+
+const getOpenAIToken = async () => {
+  const token = await storage.getItem("openai-token")
+  return token
+}
+
+const getRigoFeedback = async (readme: string, currentCode: string) => {
+  const payload = {
+    current_code: Buffer.from(currentCode).toString("base64"), // Encode currentCode as base64
+    tutorial: Buffer.from(readme).toString("base64"), // Encode readme as base64
   }
-};
+
+  const session = await storage.getItem("bc-payload")
+
+  const response = await _fetch(`${RIGOBOT_HOST}/v1/conversation/feedback/`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Token ${session.rigobot.key}`,
+    },
+    body: JSON.stringify(payload),
+  })
+
+  const responseData = await response.json()
+  return responseData.feedback
+}
 
 const publish = async (config: any) => {
   const keys = [
@@ -88,79 +131,79 @@ const publish = async (config: any) => {
     "repository",
     "author",
     "title",
-  ];
+  ]
 
-  const payload: { [key: string]: string } = {};
+  const payload: { [key: string]: string } = {}
   for (const k of keys) 
-config[k] ? (payload[k] = config[k]) : null;
+config[k] ? (payload[k] = config[k]) : null
   try {
-    console.log("Package to publish:", payload);
-    cli.action.start("Updating package information...");
-    await cli.wait(1000);
+    console.log("Package to publish:", payload)
+    cli.action.start("Updating package information...")
+    await cli.wait(1000)
     const data = await fetch(`${HOST}/v1/package/${config.slug}`, {
       method: "PUT",
       body: JSON.stringify(payload),
-    });
-    cli.action.stop("ready");
-    return data;
+    })
+    cli.action.stop("ready")
+    return data
   } catch (error) {
-    console.log("payload", payload);
-    Console.error((error as TypeError).message);
-    Console.debug(error);
-    throw error;
+    console.log("payload", payload)
+    Console.error((error as TypeError).message)
+    Console.debug(error)
+    throw error
   }
-};
+}
 
 const update = async (config: any) => {
   try {
-    cli.action.start("Updating package information...");
-    await cli.wait(1000);
+    cli.action.start("Updating package information...")
+    await cli.wait(1000)
     const data = await fetch(`${HOST}/v1/package/`, {
       method: "POST",
       body: JSON.stringify(config),
-    });
-    cli.action.stop("ready");
-    return data;
+    })
+    cli.action.stop("ready")
+    return data
   } catch (error) {
-    Console.error((error as any).message);
-    Console.debug(error);
-    throw error;
+    Console.error((error as any).message)
+    Console.debug(error)
+    throw error
   }
-};
+}
 
 const getPackage = async (slug: string) => {
   try {
-    cli.action.start("Downloading package information...");
-    await cli.wait(1000);
-    const data = await fetch(`${HOST}/v1/package/${slug}`);
-    cli.action.stop("ready");
-    return data;
+    cli.action.start("Downloading package information...")
+    await cli.wait(1000)
+    const data = await fetch(`${HOST}/v1/package/${slug}`)
+    cli.action.stop("ready")
+    return data
   } catch (error) {
     if ((error as any).status === 404)
-      Console.error(`Package ${slug} does not exist`);
+      Console.error(`Package ${slug} does not exist`)
     else 
-Console.error(`Package ${slug} does not exist`);
-    Console.debug(error);
-    throw error;
+Console.error(`Package ${slug} does not exist`)
+    Console.debug(error)
+    throw error
   }
-};
+}
 
 const getLangs = async () => {
   try {
-    cli.action.start("Downloading language options...");
-    await cli.wait(1000);
-    const data = await fetch(`${HOST}/v1/package/language`);
-    cli.action.stop("ready");
-    return data;
+    cli.action.start("Downloading language options...")
+    await cli.wait(1000)
+    const data = await fetch(`${HOST}/v1/package/language`)
+    cli.action.stop("ready")
+    return data
   } catch (error) {
     if ((error as any).status === 404)
-      Console.error("Package slug does not exist");
+      Console.error("Package slug does not exist")
     else 
-Console.error("Package slug does not exist");
-    Console.debug(error);
-    throw error;
+Console.error("Package slug does not exist")
+    Console.debug(error)
+    throw error
   }
-};
+}
 
 const getAllPackages = async ({
   lang = "",
@@ -170,25 +213,34 @@ const getAllPackages = async ({
   slug?: string;
 }) => {
   try {
-    cli.action.start("Downloading packages...");
-    await cli.wait(1000);
+    cli.action.start("Downloading packages...")
+    await cli.wait(1000)
     const data = await fetch(
       `${HOST}/v1/package/all?limit=100&language=${lang}&slug=${slug}`
-    );
-    cli.action.stop("ready");
-    return data;
+    )
+    cli.action.stop("ready")
+    return data
   } catch (error) {
-    Console.error(`Package ${slug} does not exist`);
-    Console.debug(error);
-    throw error;
+    Console.error(`Package ${slug} does not exist`)
+    Console.debug(error)
+    throw error
   }
-};
+}
 
 const APIError = (error: TypeError | string, code?: number) => {
-  const message: string = (error as TypeError).message || (error as string);
-  const _err = new Error(message) as any;
-  _err.status = code || 400;
-  return _err;
-};
+  const message: string = (error as TypeError).message || (error as string)
+  const _err = new Error(message) as any
+  _err.status = code || 400
+  return _err
+}
 
-export default { login, publish, update, getPackage, getLangs, getAllPackages };
+export default {
+  login,
+  publish,
+  update,
+  getPackage,
+  getLangs,
+  getAllPackages,
+  getRigoFeedback,
+  getOpenAIToken,
+}