spice-js 2.6.39 → 2.6.41

package/build/artificial_intelligence/AI.js

@@ -0,0 +1,299 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _fs = _interopRequireWildcard(require("fs"));
+
+var _promises = require("stream/promises");
+
+var _child_process = require("child_process");
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+var crypto = require("crypto");
+
+var path = require("path");
+
+class AI {
+  constructor(args) {
+    if (args === void 0) {
+      args = {};
+    }
+
+    this.provider = args.provider || spice.config.ai.default_driver;
+    console.log(this.provider, args.provider, spice.config.ai.default_driver);
+    this.options = _lodash.default.merge(spice.config.ai.drivers[this.provider], args.options); //console.log(this.provider_name, spice.config.ai.providers)
+
+    this.Provider = spice.config.ai.providers[this.provider];
+  }
+
+  createUniqueDirectory() {
+    var timestamp = new Date().toISOString().replace(/[:.-]/g, "");
+    var randomString = crypto.randomBytes(4).toString("hex");
+    var uniqueDirName = "job_" + timestamp + "_" + randomString;
+    var project_root = path.resolve(spice.root_path, "..");
+    var storageDir = path.join(project_root, "storage/jobs");
+    var uniqueDir = path.join(storageDir, uniqueDirName);
+
+    if (!_fs.default.existsSync(storageDir)) {
+      _fs.default.mkdirSync(storageDir, {
+        recursive: true
+      });
+    }
+
+    _fs.default.mkdirSync(uniqueDir);
+
+    return uniqueDir;
+  }
+
+  extractOrStoreFile(fileStream, outputDir, supportedFileTypes) {
+    var _this = this;
+
+    return _asyncToGenerator(function* () {
+      // Ensure the output directory exists
+      if (!_fs.default.existsSync(outputDir)) {
+        _fs.default.mkdirSync(outputDir, {
+          recursive: true
+        });
+      } // Create a temporary file to store the input
+
+
+      var tempFilePath = path.join(outputDir, "temp_input");
+      yield (0, _promises.pipeline)(fileStream, _fs.default.createWriteStream(tempFilePath));
+
+      try {
+        // Check file type
+        var fileType = yield _this.getFileType(tempFilePath);
+
+        if (_lodash.default.includes(supportedFileTypes, fileType)) {
+          // If it's a JPEG or PNG, just move it to the output directory
+          var timestamp = new Date().toISOString().replace(/[:.-]/g, "");
+          var extension = fileType === "jpeg" ? "jpg" : fileType;
+          var outputPath = path.join(outputDir, timestamp + "." + extension);
+
+          _fs.default.renameSync(tempFilePath, outputPath);
+
+          return [{
+            type: fileType,
+            media_type: _this.getMimeType(fileType),
+            path: outputPath
+          }];
+        } else {
+          // If it's a PDF, extract pages
+          if (fileType === "pdf") {
+            var outputPrefix = path.join(outputDir, "page"); // Use pdftoppm (part of poppler-utils) to convert PDF to images
+
+            yield new Promise((resolve, reject) => {
+              var process = (0, _child_process.spawn)("pdftoppm", ["-jpeg", tempFilePath, outputPrefix]);
+              process.on("close", code => {
+                if (code === 0) resolve();else reject(new Error("pdftoppm process exited with code " + code));
+              });
+            }); // Get a list of extracted images
+
+            var files = _fs.default.readdirSync(outputDir);
+
+            var images = files.filter(file => file.startsWith("page") && file.endsWith(".jpg"));
+            return images.map(image => {
+              return {
+                type: "jpeg",
+                media_type: _this.getMimeType("jpeg"),
+                path: path.join(outputDir, image)
+              };
+            });
+          } else {
+            throw new Error("Unsupported file type. Only PDF, JPEG, and PNG are supported.");
+          }
+        }
+      } catch (error) {
+        console.error("Error processing file:", error);
+        throw error;
+      } finally {
+        // Clean up the temporary input file
+        console.log("Cleaning up temporary file:", tempFilePath);
+
+        if (_fs.default.existsSync(tempFilePath)) {
+          _fs.default.unlinkSync(tempFilePath);
+        }
+      }
+    })();
+  }
+
+  getMimeType(fileType) {
+    // Mapping of file extensions to MIME types
+    var mimeTypes = {
+      jpeg: "image/jpeg",
+      jpg: "image/jpeg",
+      // Adding 'jpg' as it's a common alias for 'jpeg'
+      png: "image/png",
+      gif: "image/gif",
+      bmp: "image/bmp",
+      webp: "image/webp",
+      svg: "image/svg+xml",
+      pdf: "application/pdf",
+      txt: "text/plain",
+      html: "text/html",
+      css: "text/css",
+      js: "application/javascript",
+      json: "application/json",
+      xml: "application/xml",
+      csv: "text/csv",
+      mp3: "audio/mpeg",
+      wav: "audio/wav",
+      mp4: "video/mp4",
+      avi: "video/x-msvideo",
+      mov: "video/quicktime",
+      zip: "application/zip",
+      rar: "application/vnd.rar",
+      "7z": "application/x-7z-compressed" // Add more MIME types as needed
+
+    }; // Ensure the fileType is a string and convert it to lowercase
+
+    if (typeof fileType !== "string") {
+      throw new TypeError("fileType must be a string");
+    }
+
+    var ext = fileType.toLowerCase(); // Return the MIME type if found, otherwise return the default
+
+    return mimeTypes[ext] || "application/octet-stream";
+  }
+
+  getFileType(filePath) {
+    return _asyncToGenerator(function* () {
+      return new Promise((resolve, reject) => {
+        var fileSignature = Buffer.alloc(8);
+
+        _fs.default.open(filePath, "r", (err, fd) => {
+          if (err) reject(err);
+
+          _fs.default.read(fd, fileSignature, 0, 8, 0, err => {
+            if (err) reject(err);
+
+            _fs.default.close(fd, err => {
+              if (err) console.error("Error closing file:", err);
+            });
+
+            var hex = fileSignature.toString("hex");
+
+            if (hex.startsWith("ffd8")) {
+              resolve("jpeg");
+            } else if (hex.startsWith("89504e47")) {
+              resolve("png");
+            } else if (fileSignature.toString("ascii").startsWith("%PDF")) {
+              resolve("pdf");
+            } else {
+              resolve("unknown");
+            }
+          });
+        });
+      });
+    })();
+  }
+
+  deleteFolderRecursive(dirPath) {
+    var _this2 = this;
+
+    return _asyncToGenerator(function* () {
+      if (_fs.default.existsSync(dirPath)) {
+        for (var entry of _fs.default.readdirSync(dirPath)) {
+          var entryPath = path.join(dirPath, entry);
+
+          if (_fs.default.lstatSync(entryPath).isDirectory()) {
+            yield _this2.deleteFolderRecursive(entryPath);
+          } else {
+            yield _fs.default.promises.unlink(entryPath);
+          }
+        }
+
+        yield _fs.default.promises.rmdir(dirPath);
+      }
+    })();
+  }
+
+  processFiles(files) {
+    var _this3 = this;
+
+    return _asyncToGenerator(function* () {
+      var types = _this3.getSupportedFileTypes();
+
+      var outputDir = _this3.createUniqueDirectory();
+
+      return (yield Promise.all(files.map(
+      /*#__PURE__*/
+      function () {
+        var _ref = _asyncToGenerator(function* (fileStream) {
+          //let type = await this.getFileType(fileStream);
+          var imagePaths = yield _this3.extractOrStoreFile(fileStream, outputDir, types);
+          return imagePaths;
+        });
+
+        return function (_x) {
+          return _ref.apply(this, arguments);
+        };
+      }()))).flat();
+    })();
+  }
+
+  getSupportedFileTypes(options) {
+    if (this.Provider === undefined) {
+      throw new Error("AI provider " + this.provider + " is not defined");
+    }
+
+    var provider = new this.Provider(this.options);
+    return provider.getSupportedTypes();
+  }
+
+  prompt(prompt, _ref2, options) {
+    var _this4 = this;
+
+    return _asyncToGenerator(function* () {
+      var {
+        files,
+        system_message,
+        prompt_options
+      } = _ref2;
+      var context_files = yield _this4.processFiles(files);
+
+      try {
+        if (options) {
+          _this4.options = _lodash.default.merge(_this4.options, options);
+        } //console.log(this.Provider);
+
+
+        if (_this4.Provider === undefined) {
+          throw new Error("AI provider " + _this4.provider + " is not defined");
+        }
+
+        var provider = new _this4.Provider(_this4.options);
+        return yield provider.prompt(prompt, {
+          prompt_options,
+          system_message,
+          files: context_files
+        });
+      } catch (e) {
+        console.error(e);
+        return {
+          error: e.message
+        };
+      } finally {
+        for (var context_file of context_files) {
+          var directory = path.dirname(context_file.path);
+          yield _this4.deleteFolderRecursive(directory);
+        }
+      }
+    })();
+  }
+
+}
+
+exports.default = AI;

package/build/config/ai.js

@@ -0,0 +1,3 @@
+"use strict";
+
+module.exports = {};

package/build/index.js

@@ -1,7 +1,7 @@
 "use strict";
 
 exports.__esModule = true;
-exports.default = exports.status = exports.addTask = exports.MapType = exports.SpiceCache = exports.MailFile = exports.Storage = exports.LocalStorage = exports.DebugStorage = exports.MailDebug = exports.DataType = exports.Mail = exports.RestHelper = exports.Serializer = exports.Crypt = exports.SpiceModel = exports.ResourceLifecycleTriggered = exports.SocketEventDriver = exports.SpiceEventDriver = exports.EventDebugger = exports.Event = void 0;
+exports.default = exports.status = exports.addTask = exports.MapType = exports.SpiceCache = exports.MailFile = exports.AI = exports.Storage = exports.LocalStorage = exports.DebugStorage = exports.MailDebug = exports.DataType = exports.Mail = exports.RestHelper = exports.Serializer = exports.Crypt = exports.SpiceModel = exports.ResourceLifecycleTriggered = exports.SocketEventDriver = exports.SpiceEventDriver = exports.EventDebugger = exports.Event = void 0;
 
 var _Event = _interopRequireDefault(require("./events/Event"));
 
@@ -65,6 +65,10 @@ var _Storage = _interopRequireDefault(require("./storage/Storage"));
 
 exports.Storage = _Storage.default;
 
+var _Ai = _interopRequireDefault(require("./artificial_intelligence/Ai.js"));
+
+exports.AI = _Ai.default;
+
 var _File = _interopRequireDefault(require("./mail/providers/File"));
 
 exports.MailFile = _File.default;
@@ -104,7 +108,9 @@ require("dotenv").config({
 
 var Validate = require("koa-validation");
 
-var koaBody = require("koa-body");
+var {
+  koaBody
+} = require("koa-body");
 
 spice.parent_app_dir = path.resolve("./");
 spice.root_path = path.resolve("./build/");

package/build/mail/providers/File.js

@@ -3,15 +3,17 @@
 exports.__esModule = true;
 exports.default = void 0;
 
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
 
 function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
 
-var fs = require('fs-extra');
-
-var path = require('path');
+var fs = require("fs-extra");
 
-var open = require("open");
+var path = require("path");
 
 class File {
   constructor(args) {
@@ -22,7 +24,7 @@ class File {
     this.sender = args.sender;
     this.subject = args.subject;
     this.htmlText = args.htmlText;
-    this.dest = path.join(path.resolve('./'), 'storage/mail');
+    this.dest = path.join(path.resolve("./"), "storage/mail");
 
     if (args.path) {
       this.dest = path.resolve(args.path);
@@ -37,6 +39,8 @@ class File {
         options = {};
       }
 
+      var openModule = yield Promise.resolve().then(() => _interopRequireWildcard(require("open")));
+      var open = openModule.default;
       var email = {
         to: options.to,
         from: options.sender || _this.sender,