omegga 1.2.8 → 1.3.0

package/dist/omegga/plugin.js

@@ -1,371 +1,426 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PluginLoader = exports.PluginStorage = void 0;
-const logger_1 = __importDefault(require("../logger"));
-const softconfig_1 = __importDefault(require("../softconfig"));
-const fs_1 = __importDefault(require("fs"));
-const nedb_promises_1 = __importDefault(require("nedb-promises"));
-const path_1 = __importDefault(require("path"));
-const plugin_jsonrpc_stdio_1 = __importDefault(require("./plugin/plugin_jsonrpc_stdio"));
-const plugin_node_safe_1 = __importDefault(require("./plugin/plugin_node_safe"));
-const plugin_node_unsafe_1 = __importDefault(require("./plugin/plugin_node_unsafe"));
-// key-value storage for a plugin
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const logger = require("../logger.js");
+const softconfig = require("../softconfig.js");
+const Datastore = require("nedb-promises");
+const fs = require("node:fs");
+const path = require("node:path");
+const plugin_jsonrpc_stdio = require("./plugin/plugin_jsonrpc_stdio.js");
+const plugin_node_safe = require("./plugin/plugin_node_safe.js");
+const plugin_node_unsafe = require("./plugin/plugin_node_unsafe.js");
 class PluginStorage {
-    constructor(store, plugin) {
-        this.store = store;
-        this.plugin = plugin;
-        this.name = plugin.getName();
+  constructor(store, plugin) {
+    this.store = store;
+    this.plugin = plugin;
+    this.name = plugin.getName();
+  }
+  // get the initial config values
+  getDefaultConfig() {
+    const doc = this.plugin.getDocumentation();
+    if (!doc) return {};
+    if (!doc.config) return {};
+    const config = {};
+    for (const k in doc.config) {
+      config[k] = doc.config[k].default;
     }
-    // get the initial config values
-    getDefaultConfig() {
-        const doc = this.plugin.getDocumentation();
-        // check if the documentation object exists and whether it has a config field
-        if (!doc)
-            return {};
-        if (!doc.config)
-            return {};
-        // insert values from default config values
-        const config = {};
-        for (const k in doc.config) {
-            config[k] = doc.config[k].default;
-        }
-        return config;
-    }
-    // set the config field for this plugin
-    async setConfig(value) {
-        await this.store.update({ type: 'config', plugin: this.name }, {
-            $set: { value },
-        }, { upsert: true });
-    }
-    // get the config for this plugin
-    async getConfig() {
-        const config = await this.store.findOne({
-            type: 'config',
-            plugin: this.name,
-        });
-        if (!config)
-            return null;
-        return config.value;
-    }
-    /** Wipes the configs for the plugin. */
-    async wipeConfig() {
-        await this.store.remove({ type: 'config', plugin: this.name }, { multi: true });
+    return config;
+  }
+  // set the config field for this plugin
+  async setConfig(value) {
+    await this.store.update(
+      { type: "config", plugin: this.name },
+      {
+        $set: { value }
+      },
+      { upsert: true }
+    );
+  }
+  // get the config for this plugin
+  async getConfig() {
+    const config = await this.store.findOne({
+      type: "config",
+      plugin: this.name
+    });
+    if (!config) return null;
+    return config.value;
+  }
+  /** Wipes the configs for the plugin. */
+  async wipeConfig() {
+    await this.store.remove(
+      { type: "config", plugin: this.name },
+      { multi: true }
+    );
+  }
+  /** Initializes the configs for the plugin into the database and sets default configs. */
+  async init() {
+    const defaultConf = this.getDefaultConfig();
+    const config = await this.getConfig();
+    await this.setConfig({
+      // use default config
+      ...defaultConf,
+      // override with actual config values
+      ...config ? config : {}
+    });
+  }
+  // get a stored object
+  async get(key) {
+    if (typeof key !== "string" || key.length === 0) return;
+    const obj = await this.store.findOne({
+      type: "store",
+      plugin: this.name,
+      key
+    });
+    if (!obj) return null;
+    return obj.value;
+  }
+  // delete a stored object
+  async delete(key) {
+    if (typeof key !== "string" || key.length === 0) return;
+    await this.store.remove({ type: "store", plugin: this.name, key }, {});
+  }
+  // clear all stored values
+  async wipe() {
+    await this.store.remove(
+      { type: "store", plugin: this.name },
+      { multi: true }
+    );
+  }
+  // count number of objects in store
+  async count() {
+    return await this.store.count({ type: "store", plugin: this.name });
+  }
+  // get keys of all objects in store
+  async keys() {
+    const objects = await this.store.find({
+      type: "store",
+      plugin: this.name
+    });
+    return objects.map((o) => o.key);
+  }
+  // set a stored value
+  async set(key, value) {
+    if (typeof key !== "string" || key.length === 0) return;
+    await this.store.update(
+      { type: "store", plugin: this.name, key },
+      { $set: { value } },
+      { upsert: true }
+    );
+  }
+}
+class PluginLoader {
+  constructor(workDir, omegga) {
+    this.path = path.join(workDir, softconfig.default.PLUGIN_PATH);
+    this.omegga = omegga;
+    this.store = Datastore.create({
+      filename: path.join(workDir, softconfig.default.DATA_PATH, softconfig.default.PLUGIN_STORE),
+      autoload: true
+    });
+    this.store.persistence.setAutocompactionInterval(1e3 * 60 * 5);
+    this.plugins = [];
+    logger.default.verbose("Loading plugin formats");
+    this.formats = [plugin_jsonrpc_stdio.default, plugin_node_safe.default, plugin_node_unsafe.default];
+    logger.default.verbose("Found plugin formats:", this.formats);
+    if (omegga) {
+      omegga.on("chatcmd:help", this.showHelp.bind(this));
+      omegga.on("cmd:plugins", this.showHelp.bind(this));
     }
-    /** Initializes the configs for the plugin into the database and sets default configs. */
-    async init() {
-        // get default and configured values
-        const defaultConf = this.getDefaultConfig();
-        const config = await this.getConfig();
-        await this.setConfig({
-            // use default config
-            ...defaultConf,
-            // override with actual config values
-            ...(config ? config : {}),
-        });
+  }
+  // determine if this command is a command on the plugin
+  isCommand(cmd) {
+    return cmd === "plugins" || this.plugins.some((p) => p.isCommand(cmd));
+  }
+  // unload and load all installed plugins
+  async reload() {
+    let ok = true;
+    logger.default.verbose("Reloading plugins");
+    for (const p of this.plugins) {
+      try {
+        if (p.isLoaded()) await p.unload();
+        if (!p.isLoaded()) {
+          if (p.isEnabled()) {
+            logger.default.verbose(
+              "Loading plugin",
+              p.constructor.getFormat(),
+              p.getName().underline
+            );
+            ok = await p.load() || ok;
+          }
+        } else {
+          logger.default.errorp(
+            "Did not successfully unload plugin",
+            p.getName().brightRed.underline
+          );
+          ok = false;
+        }
+      } catch (err) {
+        logger.default.errorp(
+          "Error loading plugin",
+          p.getName().brightRed.underline,
+          err
+        );
+        ok = false;
+      }
     }
-    // get a stored object
-    async get(key) {
-        if (typeof key !== 'string' || key.length === 0)
-            return;
-        const obj = await this.store.findOne({
-            type: 'store',
-            plugin: this.name,
-            key,
-        });
-        if (!obj)
-            return null;
-        return obj.value;
+    logger.default.verbose("Finished reloading plugins");
+    return ok;
+  }
+  // stop all plugins from running
+  async unload() {
+    logger.default.verbose("Unloading plugins");
+    let ok = true;
+    for (const p of this.plugins) {
+      try {
+        if (p.isLoaded()) {
+          if (!await p.unload()) {
+            logger.default.errorp(
+              "Could not unloading plugin",
+              p.getName().brightRed.underline
+            );
+            ok = false;
+            continue;
+          } else {
+            logger.default.verbose("Unloaded", p.getName().underline);
+          }
+        }
+      } catch (e) {
+        logger.default.errorp(
+          "Error unloading plugin",
+          p.getName().brightRed.underline
+        );
+        ok = false;
+      }
     }
-    // delete a stored object
-    async delete(key) {
-        if (typeof key !== 'string' || key.length === 0)
-            return;
-        await this.store.remove({ type: 'store', plugin: this.name, key }, {});
+    return ok;
+  }
+  /** Scans a plugin at the specified directory and create a Plugin object. */
+  async scanPlugin(dir) {
+    logger.default.verbose("Scanning plugin", dir.underline);
+    if (!fs.existsSync(dir)) {
+      logger.default.errorp("Plugin directory does not exist", dir.brightRed.underline);
+      return;
     }
-    // clear all stored values
-    async wipe() {
-        await this.store.remove({ type: 'store', plugin: this.name }, { multi: true });
+    if (!fs.statSync(dir).isDirectory()) {
+      logger.default.errorp("Plugin must be a directory", dir.brightRed.underline);
+      return;
     }
-    // count number of objects in store
-    async count() {
-        return await this.store.count({ type: 'store', plugin: this.name });
+    const PluginFormat = this.formats.find((f) => f.canLoad(dir));
+    if (!PluginFormat) {
+      logger.default.errorp("Missing plugin format for", dir);
+      return;
     }
-    // get keys of all objects in store
-    async keys() {
-        const objects = await this.store.find({
-            type: 'store',
-            plugin: this.name,
-        });
-        return objects.map(o => o.key);
+    try {
+      const plugin = PluginFormat && new PluginFormat(dir, this.omegga);
+      if (!plugin.getDocumentation()) {
+        logger.default.errorp("Missing/invalid plugin documentation for", dir);
+        return;
+      }
+      const storage = new PluginStorage(this.store, plugin);
+      await storage.init();
+      plugin.setStorage(storage);
+      return plugin;
+    } catch (e) {
+      logger.default.errorp(
+        "Error loading plugin",
+        dir.brightRed.underline,
+        PluginFormat,
+        e
+      );
     }
-    // set a stored value
-    async set(key, value) {
-        if (typeof key !== 'string' || key.length === 0)
-            return;
-        await this.store.update({ type: 'store', plugin: this.name, key }, { $set: { value } }, { upsert: true });
+  }
+  static calculateLoadOrder(unsortedPlugins) {
+    if (!unsortedPlugins.length) {
+      return [];
     }
-}
-exports.PluginStorage = PluginStorage;
-/*
-  Plugin Loader and Scanner
-    Allows omegga to scan in plugins and load them
-*/
-class PluginLoader {
-    constructor(workDir, omegga) {
-        this.path = path_1.default.join(workDir, softconfig_1.default.PLUGIN_PATH);
-        this.omegga = omegga;
-        this.store = nedb_promises_1.default.create({
-            filename: path_1.default.join(workDir, softconfig_1.default.DATA_PATH, softconfig_1.default.PLUGIN_STORE),
-            autoload: true,
-        });
-        this.store.persistence.setAutocompactionInterval(1000 * 60 * 5);
-        this.plugins = [];
-        logger_1.default.verbose('Loading plugin formats');
-        this.formats = [plugin_jsonrpc_stdio_1.default, plugin_node_safe_1.default, plugin_node_unsafe_1.default];
-        logger_1.default.verbose('Found plugin formats:', this.formats);
-        if (omegga) {
-            // soon to be deprecated !help
-            omegga.on('chatcmd:help', this.showHelp.bind(this));
-            // use /plugins to get help
-            omegga.on('cmd:plugins', this.showHelp.bind(this));
+    const depGraph = unsortedPlugins.reduce((graph, plugin) => {
+      const name = plugin.getName();
+      const {
+        dependencies = {},
+        loadAfter = [],
+        loadBefore = []
+      } = plugin.pluginConfig ?? {};
+      graph[name] ??= {};
+      graph[name].plugin ??= plugin;
+      graph[name].behind ??= [];
+      graph[name].inDegree ??= 0;
+      for (const depName of [...loadAfter, ...Object.keys(dependencies)]) {
+        graph[name].behind.push(depName);
+        graph[depName] ??= {};
+        graph[depName].inDegree ??= 0;
+        graph[depName].inDegree++;
+      }
+      for (const depName of [...loadBefore]) {
+        graph[depName] ??= {};
+        graph[depName].behind ??= [];
+        graph[depName].behind.push(name);
+        graph[name].inDegree++;
+      }
+      return graph;
+    }, {});
+    let zeros = Object.entries(depGraph).reduce(
+      (arr, [name, { inDegree }]) => {
+        if (inDegree === 0) {
+          arr.push(name);
         }
-    }
-    // determine if this command is a command on the plugin
-    isCommand(cmd) {
-        return cmd === 'plugins' || this.plugins.some(p => p.isCommand(cmd));
-    }
-    // unload and load all installed plugins
-    async reload() {
-        let ok = true;
-        logger_1.default.verbose('Reloading plugins');
-        for (const p of this.plugins) {
-            try {
-                // unload the plugin if it's loaded
-                if (p.isLoaded())
-                    await p.unload();
-                // load the plugin if it successfully unloaded
-                if (!p.isLoaded()) {
-                    // only load it if it is enabled
-                    if (p.isEnabled()) {
-                        logger_1.default.verbose('Loading plugin', p.constructor.getFormat(), p.getName().underline);
-                        ok = (await p.load()) || ok;
-                    }
-                }
-                else {
-                    logger_1.default.errorp('Did not successfully unload plugin', p.getName().brightRed.underline);
-                    ok = false;
-                }
-            }
-            catch (err) {
-                logger_1.default.errorp('Error loading plugin', p.getName().brightRed.underline, err);
-                ok = false;
-            }
+        return arr;
+      },
+      []
+    );
+    const result = [];
+    while (zeros.length) {
+      result.unshift([...zeros]);
+      const nextZero = [];
+      for (const node of zeros) {
+        for (const neighbor of depGraph[node].behind) {
+          depGraph[neighbor].inDegree--;
+          if (depGraph[neighbor].inDegree === 0) {
+            nextZero.push(neighbor);
+          }
         }
-        logger_1.default.verbose('Finished reloading plugins');
-        return ok;
+      }
+      zeros = nextZero;
     }
-    // stop all plugins from running
-    async unload() {
-        logger_1.default.verbose('Unloading plugins');
-        let ok = true;
-        // potentually use Promise.all
-        for (const p of this.plugins) {
-            try {
-                // unload the plugin if it's loaded
-                if (p.isLoaded()) {
-                    if (!(await p.unload())) {
-                        logger_1.default.errorp('Could not unloading plugin', p.getName().brightRed.underline);
-                        ok = false;
-                        continue;
-                    }
-                    else {
-                        logger_1.default.verbose('Unloaded', p.getName().underline);
-                    }
-                }
-            }
-            catch (e) {
-                logger_1.default.errorp('Error unloading plugin', p.getName().brightRed.underline);
-                ok = false;
-            }
-        }
-        return ok;
+    if (Object.values(depGraph).some(({ inDegree }) => inDegree > 0)) {
+      logger.default.verbose(
+        "Cyclic or missing dependencies detected in plugins. Could not resolve load order."
+      );
+      return [];
     }
-    /** Scans a plugin at the specified directory and create a Plugin object. */
-    async scanPlugin(dir) {
-        logger_1.default.verbose('Scanning plugin', dir.underline);
-        if (!fs_1.default.existsSync(dir)) {
-            logger_1.default.errorp('Plugin directory does not exist', dir.brightRed.underline);
-            return;
-        }
-        if (!fs_1.default.statSync(dir).isDirectory()) {
-            logger_1.default.errorp('Plugin must be a directory', dir.brightRed.underline);
-            return;
-        }
-        // find a plugin format that can load in this plugin
-        const PluginFormat = this.formats.find(f => f.canLoad(dir));
-        // let users know if there's a missing plugin format
-        if (!PluginFormat) {
-            logger_1.default.errorp('Missing plugin format for', dir);
-            return;
-        }
-        try {
-            // create the plugin format
-            const plugin = PluginFormat && new PluginFormat(dir, this.omegga);
-            if (!plugin.getDocumentation()) {
-                logger_1.default.errorp('Missing/invalid plugin documentation for', dir);
-                return;
-            }
-            // create its storage
-            const storage = new PluginStorage(this.store, plugin);
-            await storage.init();
-            // load the storage in
-            plugin.setStorage(storage);
-            // if there is a plugin format, create the plugin instance (but don't load yet)
-            return plugin;
-        }
-        catch (e) {
-            // if a plugin format fails to load, prevent omegga from dying
-            logger_1.default.errorp('Error loading plugin', dir.brightRed.underline, PluginFormat, e);
-        }
+    return result.map(
+      (interchangeablePlugins) => interchangeablePlugins.map((name) => depGraph[name].plugin).sort((a, b) => a.getName().localeCompare(b.getName()))
+    ).flat().sort((a, b) => {
+      const A = a.pluginConfig?.loadPriority;
+      const B = b.pluginConfig?.loadPriority;
+      const aU = A == null;
+      const bU = B == null;
+      if (aU && bU) return 0;
+      if (aU) return B <= 0 ? 1 : -1;
+      if (bU) return A <= 0 ? -1 : 1;
+      return A - B;
+    });
+  }
+  /** Scans plugin directory for plugins and builds their documentation. */
+  async scan() {
+    logger.default.verbose("Scanning plugin directory");
+    if (!fs.existsSync(this.path)) {
+      logger.default.verbose("Plugin directory is missing");
+      return false;
     }
-    /** Scans plugin directory for plugins and builds their documentation. */
-    async scan() {
-        logger_1.default.verbose('Scanning plugin directory');
-        // plugin directory doesn't exist
-        if (!fs_1.default.existsSync(this.path)) {
-            logger_1.default.verbose('Plugin directory is missing');
-            return false;
-        }
-        // make sure there are no plugins running
-        if (this.plugins.some(p => p.isLoaded())) {
-            logger_1.default.errorp('Cannot re-scan plugins while a plugin is loaded');
-            return false;
-        }
-        // find all directories in the plugin path
-        this.plugins = (await Promise.all(fs_1.default
-            .readdirSync(this.path)
-            .map(dir => path_1.default.join(this.path, dir)) // convert from local paths
-            .map(async (dir) => this.scanPlugin(dir))))
-            // remove plugins without formats
-            .filter(p => p);
-        logger_1.default.verbose('Finished scanning plugin directory');
-        logger_1.default.verbose(`Found ${this.plugins.length} plugins`, this.plugins.map(p => p.getName()));
-        this.buildDocumentation();
-        return true;
+    if (this.plugins.some((p) => p.isLoaded())) {
+      logger.default.errorp("Cannot re-scan plugins while a plugin is loaded");
+      return false;
     }
-    // show helptext
-    showHelp(player, ...args) {
-        var _a, _b;
-        // send the message to the player
-        const send = (msg) => this.omegga.whisper(player, msg);
-        // available commands and documentation from the plugin system
-        const commands = (_a = this.commands) !== null && _a !== void 0 ? _a : {};
-        const docs = (_b = this.documentation) !== null && _b !== void 0 ? _b : {};
-        const splitHelper = (objs) => {
-            const lines = [];
-            while (objs.length > 0) {
-                const [item] = objs.splice(0, 1);
-                if (!lines.length || lines[lines.length - 1].length + item.length > 150)
-                    lines.push(item);
-                else
-                    lines[lines.length - 1] += ', ' + item;
-            }
-            return lines;
-        };
-        // no arguments
-        if (!args.length) {
-            send('"Use <code>/plugins plugin</>, <code>/plugins !command</>, <code>/plugins /command</> for more information"');
-            const plugins = Object.keys(docs).map(d => `<color=\\"${docs[d]._plugin.isLoaded() ? 'aaffaa' : 'aaaaaa'}\\">${d}</>`);
-            if (!plugins.length) {
-                send('"<b>No Installed Plugins</>"');
-            }
-            else {
-                const lines = splitHelper(plugins);
-                send(`"<b>Installed Plugins</>: ${lines[0]}"`);
-                for (let i = 1; i < lines.length; i++)
-                    send(`"${lines[i]}"`);
-            }
-            // plugin or command argument
+    const unsortedPlugins = (await Promise.all(
+      fs.readdirSync(this.path).map((dir) => path.join(this.path, dir)).map(async (dir) => this.scanPlugin(dir))
+    )).filter((p) => p);
+    this.plugins = PluginLoader.calculateLoadOrder(unsortedPlugins);
+    logger.default.verbose("Finished scanning plugin directory");
+    logger.default.verbose(
+      `Found ${this.plugins.length} plugins.Loading in this order: `,
+      this.plugins.map((p) => p.getName())
+    );
+    this.buildDocumentation();
+    return true;
+  }
+  // show helptext
+  showHelp(player, ...args) {
+    const send = (msg) => this.omegga.whisper(player, msg);
+    const commands = this.commands ?? {};
+    const docs = this.documentation ?? {};
+    const splitHelper = (objs) => {
+      const lines = [];
+      while (objs.length > 0) {
+        const [item] = objs.splice(0, 1);
+        if (!lines.length || lines[lines.length - 1].length + item.length > 150)
+          lines.push(item);
+        else lines[lines.length - 1] += ", " + item;
+      }
+      return lines;
+    };
+    if (!args.length) {
+      send(
+        '"Use <code>/plugins plugin</>, <code>/plugins !command</>, <code>/plugins /command</> for more information"'
+      );
+      const plugins = Object.keys(docs).map(
+        (d) => `<color=\\"${docs[d]._plugin.isLoaded() ? "aaffaa" : "aaaaaa"}\\">${d}</>`
+      );
+      if (!plugins.length) {
+        send('"<b>No Installed Plugins</>"');
+      } else {
+        const lines = splitHelper(plugins);
+        send(`"<b>Installed Plugins</>: ${lines[0]}"`);
+        for (let i = 1; i < lines.length; i++) send(`"${lines[i]}"`);
+      }
+    } else if (args.length > 0) {
+      const target = args.join(" ").toLowerCase();
+      if (target in docs) {
+        const doc = docs[target];
+        const desc = doc.description || "no description";
+        const color = doc._plugin.isLoaded() ? "aaffaa" : "aaaaaa";
+        send(
+          `"<b>Plugin</> <code><color=\\"${color}\\">${doc.name}</></>: ${desc}"`
+        );
+        if (doc.author)
+          send(`"<b>Author</>: <color=\\"c4d7f5\\"><b>${doc.author}</></>"`);
+        if (doc.commands && doc.commands.length > 0) {
+          const lines = splitHelper(
+            doc.commands.map((c) => `<code>${c.name}</>`)
+          );
+          send(`"<b>Commands</>: ${lines[0]}"`);
+          for (let i = 1; i < lines.length; i++) send(`"${lines[i]}"`);
         }
-        else if (args.length > 0) {
-            const target = args.join(' ').toLowerCase();
-            // argument is a plugin; render description, author, and commands
-            if (target in docs) {
-                const doc = docs[target];
-                const desc = doc.description || 'no description';
-                const color = doc._plugin.isLoaded() ? 'aaffaa' : 'aaaaaa';
-                send(`"<b>Plugin</> <code><color=\\"${color}\\">${doc.name}</></>: ${desc}"`);
-                if (doc.author)
-                    send(`"<b>Author</>: <color=\\"c4d7f5\\"><b>${doc.author}</></>"`);
-                if (doc.commands && doc.commands.length > 0) {
-                    const lines = splitHelper(doc.commands.map(c => `<code>${c.name}</>`));
-                    send(`"<b>Commands</>: ${lines[0]}"`);
-                    for (let i = 1; i < lines.length; i++)
-                        send(`"${lines[i]}"`);
-                }
-                // argument is a command
-            }
-            else if (target in commands) {
-                const cmd = commands[target];
-                const desc = cmd.description || 'no description';
-                const example = cmd.example || 'no example';
-                const color = cmd._plugin.isLoaded() ? 'aaffaa' : 'aaaaaa';
-                send(`"<b>Command</> <code><color=\\"${color}\\">${cmd.name}</></>: ${desc}"`);
-                send(`"<b>Example</>: <code>${example}</>"`);
-                if (cmd.args && cmd.args.length > 0) {
-                    send('"<b>Arguments</>:"');
-                    for (const arg of cmd.args) {
-                        const desc = arg.description || 'no description';
-                        send(`"- <code>${arg.name}</>${arg.required ? ' (required)' : ''}: ${desc}"`);
-                    }
-                }
-                else {
-                    send('"<b>Arguments</>: None"');
-                }
-                // user takes the helptext literally
-            }
-            else if (args[0] === '!command' ||
-                args[0] === '/command' ||
-                args[0] === 'plugin') {
-                send('"Use <code>/plugins [name of plugin]</> or <code>/plugins [name of !command or /command]</> for more help for the respective plugin or command"');
-                // argument is not found
-            }
-            else {
-                send('"Could not find that command or plugin"');
-            }
-            // too many arguments
-        }
-        else {
-            send('"Use <code>/plugins</> to list plugins and <code>/plugins plugin</> or <code>!help !command or /command</> for more information"');
+      } else if (target in commands) {
+        const cmd = commands[target];
+        const desc = cmd.description || "no description";
+        const example = cmd.example || "no example";
+        const color = cmd._plugin.isLoaded() ? "aaffaa" : "aaaaaa";
+        send(
+          `"<b>Command</> <code><color=\\"${color}\\">${cmd.name}</></>: ${desc}"`
+        );
+        send(`"<b>Example</>: <code>${example}</>"`);
+        if (cmd.args && cmd.args.length > 0) {
+          send('"<b>Arguments</>:"');
+          for (const arg of cmd.args) {
+            const desc2 = arg.description || "no description";
+            send(
+              `"- <code>${arg.name}</>${arg.required ? " (required)" : ""}: ${desc2}"`
+            );
+          }
+        } else {
+          send('"<b>Arguments</>: None"');
         }
+      } else if (args[0] === "!command" || args[0] === "/command" || args[0] === "plugin") {
+        send(
+          '"Use <code>/plugins [name of plugin]</> or <code>/plugins [name of !command or /command]</> for more help for the respective plugin or command"'
+        );
+      } else {
+        send('"Could not find that command or plugin"');
+      }
+    } else {
+      send(
+        '"Use <code>/plugins</> to list plugins and <code>/plugins plugin</> or <code>!help !command or /command</> for more information"'
+      );
     }
-    // generate documentation from loaded plugins
-    buildDocumentation() {
-        this.documentation = {};
-        this.commands = {};
-        for (const plugin of this.plugins) {
-            // make sure this plugin has docs
-            const doc = JSON.parse(JSON.stringify(plugin.getDocumentation()));
-            if (!doc)
-                continue;
-            const name = plugin.getName();
-            if (!name)
-                continue;
-            // add the documentation into a dictionary
-            this.documentation[name.toLowerCase()] = doc;
-            doc._plugin = plugin;
-            // add all the commands into a dictionary
-            if (doc.commands) {
-                for (const cmd of doc.commands) {
-                    this.commands[cmd.name.toLowerCase()] = cmd;
-                    cmd._plugin = plugin;
-                }
-            }
+  }
+  // generate documentation from loaded plugins
+  buildDocumentation() {
+    this.documentation = {};
+    this.commands = {};
+    for (const plugin of this.plugins) {
+      const doc = JSON.parse(JSON.stringify(plugin.getDocumentation()));
+      if (!doc) continue;
+      const name = plugin.getName();
+      if (!name) continue;
+      this.documentation[name.toLowerCase()] = doc;
+      doc._plugin = plugin;
+      if (doc.commands) {
+        for (const cmd of doc.commands) {
+          this.commands[cmd.name.toLowerCase()] = cmd;
+          cmd._plugin = plugin;
         }
+      }
     }
+  }
 }
 exports.PluginLoader = PluginLoader;
-//# sourceMappingURL=plugin.js.map
+exports.PluginStorage = PluginStorage;
+//# sourceMappingURL=plugin.js.map