@indra.ai/deva 1.0.27

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Quinn Michaels
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,391 @@
+# DEVA
+Deva is a lightweight class object that provides events and object management with inherited properties.
+
+## Install
+```bash
+$> npm i @feecting/deva
+```
+
+## Basic Structure
+```javascript
+// include the main Deva class
+const Deva = require('feecting/deva');
+
+// setup the Deva object
+const deva = new Deva({
+  agent: {
+    uid: '*uinique identifier*'
+    key: '*DEVA KEY*',
+    name: '*DEVA NAME*',
+    describe: '*DEVA LONG DESCRIPTION*',
+    prompt: {
+      emoji: '🐶',
+      text: '*DEVA*',
+      color: 'white',
+    },
+    voice: {
+      speech: 'Alex',
+      speed: 1
+    },
+    profile: {
+      emoji: 'the graphic emoji the agent travels with. 50px x 50px'
+      avatar: 'the graphic avatar the agent travels with 150px x 150px',
+      background: 'a background asset for page displays for th eagent',
+      describe: 'the profile description for the agent that is used in displays.',
+      gender: 'the preferred gender string for the agent',
+    },
+    translate(input) {
+      return input.trim();
+    },
+    parse(input) {
+      return input.trim();
+    }    
+  },
+  vars: {},
+  listeners: {},
+  modules: {},
+  func: {},
+  methods: {},
+  deva: {},
+  onStart() {},
+  onStop() {},
+  onEnter() {},
+  onExit() {},
+  onDone() {},
+  onInit() {},
+});
+
+// initialize the class
+deva.init();
+
+```
+
+## Breakdown
+### Agent
+```javascript
+this.agent
+```
+The "me" object contains the profile information for the DEVA.
+##### Data Attributes
+- **uid:** The unique id for the Deva.
+- **key:** The unique key for the Deva.
+- **name:** The name of the Deva.
+- **description:** A description of what the Deva does.
+- **prompt:** Define how prompt displays.
+  - **emoji:** The emoji for use as a prompt indicator.
+  - **text:** Short text for prompt display.
+  - **color:** The color of the prompt for the Deva.
+- **voice:** Voice properties of the Deva.
+  - **speech:** The name of the voice speech to use.
+  - **speed:** The speed of the voice.
+- **profile:** Public Profile Information
+  - **emoji:** The emoji for the Deva
+  - **avatar:** The avatar for the Deva
+  - **background:** The background image for the Deva
+  - **gender:** The gender of the Deva
+  - **describe:** A short description of the deva 100 characters or less.
+
+### Vars
+```javascript
+this.vars
+```
+The vars can be use to set local variables for the deva that need to be used in your program.
+
+There are no default variables, so the scope is for you and your imagination to figure out.
+
+##### Example
+```javascript
+...
+  vars: {
+    foo: 'bar',
+    steps: 10,
+    strings: 'Some variable string',
+    adding: 1 + 9 + 11,
+    objects: {
+      key: 'key value'
+    },
+    arrays: [
+      'value 1',
+      'value 2',
+    ]
+  }
+...
+
+```
+### Listeners
+Listeners are what you setup that allow your Deva to communicate with other Deva or parts of your application/system.
+
+```javascript
+this.listeners
+```
+
+#### Default Listeners
+
+Each Deva comes with a set of default listeners to provide basic functionality.
+
+##### Question
+The question event is the functionality that exposes the methods to the outside world. When a deva asks a question the string is parsed into a question format so that commands to access various methods can be exposed.
+
+```javascript
+const question = await this.question(`#*agent_key* *method*:*params* *question string*`);
+```
+
+##### Start
+This will trigger an event to start the Deva.
+
+```javascript
+this.talk(`*agent_key*:start`);
+```
+
+##### Stop
+This will trigger an event to stop the Deva.
+
+```javascript
+this.talk(`*agent_key*:stop`);
+```
+
+##### Status
+This will trigger an event to broadcast the Deva status.
+
+```javascript
+this.talk(`*agent_key*:status`);
+```
+
+### Deva
+```javascript
+this.deva
+```
+
+The main object for Deva that are bwlow this Deva.
+
+### Modules
+The external modules that your Deva might require to function.
+
+```javascript
+this.modules
+```
+
+
+### Func
+The functions that your deva uses to operate. Functions are not exposed through
+the api to public access.
+
+```javascript
+this.func
+```
+
+### Methods
+```javascript
+this.methods
+```
+The methods are exposed publicly through the question event that parses a string
+and sends a request to the question method that then interacts with functions, modules, and variables.
+
+### State Functions
+Provided are a set of state functions that trigger when a Deva is at various states of starting/stopping.
+
+#### onStart()
+
+The `onStart()` function runs after the `start` function has completed.
+
+```javascript
+this.onStart() {
+  // some code to run when the deva starts.
+}
+```
+
+#### onStop()
+
+The `onStop()` function runs after the `stop` function has completed.
+
+```javascript
+this.onStop() {
+  // some code to run when the deva stops
+}
+```
+
+
+#### onEnter()
+
+The `onEnter()` function runs after the `enter` event has fired.
+
+```javascript
+this.onEnter() {
+  // some code to run when the deva is loaded
+}
+```
+
+
+#### onExit()
+
+The `onExit()`function runs after the `exit` event has fired.
+
+```javascript
+this.onExit() {
+  // some code to run when the deva logs out.
+}
+```
+
+#### onDone()
+
+The `onDone()`function runs after the `done` event has fired.
+
+```javascript
+this.onDone() {
+  // some code to run when the deva logs out.
+}
+```
+
+
+#### onInit()
+
+The `onInit()` function runs after the `init()` function has completed.
+
+```javascript
+this.onInit() {
+  // some code to run when the Deva initializes.
+}
+```
+
+## Utility Functions
+
+### uid()
+Generates a unique ID that is used in packet transfer and other various ways.
+
+```javascript
+this.uid() // inside the object
+deva.uid() // outside the object
+
+// example
+this.vars.id = this.uid()
+
+```
+
+### talk(evt, resource=false)
+
+The `talk()` function is used when your Deva needs to broadcast an event that other Deva
+or functions would be listening for.
+
+```javascript
+this.talk('event', resource);  // inside the object
+deva.talk('event', resource); // outside the object
+
+// example
+const evt_id = this.uid();
+const evt_data = {
+  task_id: 1,
+  task_name: 'this is blank data',
+  task_contact: 'joe@schmo.com',
+};
+
+this.talk('big-event', {
+  id: evt_id,
+  key: this.me.key,
+  q: {
+    bot: this.me,
+    text: 'text to send to the event',
+    data: evt_data,
+  },
+  created: Date.now(),
+});
+```
+
+### listen(evt callback)
+
+The `listen` function can assign listeners to the Deva and designate which `callback`
+function to run when an event is fired.
+
+Listeners can be set up individually this way or also added to the listeners object
+independently.
+
+```javascript
+this.listen('some-event', this.func.listener);
+
+this.func.listenter = packet => {
+  console.log('some-event-fired');
+};
+
+```
+
+### once(evt, callback)
+
+The `once()` function can assign a one-time listener to a function. This is useful when returning data with an id that one Deva has submitted to another Deva. Also very useful for submit responses that are unique to the request.
+
+```javascript
+this.once(`some-once-event`, this.func.listener)
+this.func.listener = packet => {
+  console.log('some-once-event-fired');
+}
+
+```
+
+### ignore(evt, callback)
+
+The `ignore()` function removes a listener from the designated event. This is useful for adding and removing events dynamically or as needed.
+
+```javascript
+this.ignore('ignore-event', this.func.listener);
+this.func.listener = packet => {
+  console.log('ignore-event-fired');
+}
+```
+
+
+### Load(agent, opts)
+
+To add a Deva dynamically use the `load()` function. This can be utilized to add Deva to an existing Deva after the object has already been created.
+
+```javascript
+const opts = {
+  me: {...},
+  vars: {...},
+  listeners: {...},
+  deva: {...},
+  func: {...},
+  onStart() {},
+  onStop() {},
+  onEnter() {},
+  onExit() {},
+}
+this.load('deva-name', opts);
+```
+
+### unload(agent)
+To delete a Deva for any reason use `unload()`. This will delete the Deva and all it's parts from the current Deva.
+
+```javascript
+
+this.unload('deva-key');
+
+```
+
+### question(packet)
+The `question(packet)` function is a default function that allows the system to ask questions of itself or other Deva.
+
+The function checks the beginning of a string for a `#` to determine wether to issue a command to run a specific method.
+
+See [Question Listener](#question) for usage.
+
+```bash
+#deva method:params message
+```
+
+
+### status()
+The `status()` function will return the running status of the current Deva.
+
+### start()
+The `start()` function will start the Deva and run the `onStart()` state function.
+
+### stop()
+The `stop()` function will stop the Deva and run the `onStop()` state function.
+
+### init(deva=false)
+The `init()` function will initialize the Deva and run the `onInit()` state function.
+
+### initDeva()
+The `initDeva()` function will initialize the Deva located under the current Deva set. To be used in instances of a main Deva parent situation.
+
+-
+
+©2021 Quinn Michaels; All Rights Reserved.

package/examples/hello-world.js

@@ -0,0 +1,61 @@
+// Copyright (c)2021 Quinn Michaels
+// Distributed under the MIT software license, see the accompanying
+// file LICENSE.md or http://www.opensource.org/licenses/mit-license.php.
+const Deva = require('../index');
+const HelloWorld = new Deva({
+  agent: {
+    key: 'hello',
+    name: 'Hello World',
+    description: 'The most over complex Hello World in the Universe',
+    prompt: {
+      emoji: '🐶',
+      text: 'hello',
+      color: 'white',
+    },
+    voice: {
+      speech: 'Alex',
+      speed: 1
+    },
+    profile: {
+      avatar: '',
+      background: '',
+      describe: 'Hello World Deva',
+      gender: 'N',
+    },
+    translate(input) {
+      return input.trim();
+    },
+    parse(input) {
+      return input.trim();
+    }
+  },
+  vars: {
+    hello: 'Hello World'
+  },
+  listeners: {},
+  deva: {},
+  modules: {},
+  func: {
+    hello() {
+      return this.agent.translate(this.vars.hello);
+    }
+  },
+  methods: {
+    hello() {
+      return this.func.hello();
+    }
+  },
+
+  onStart() {
+    console.log(this.methods.hello());
+  },
+
+  onStop() {},
+  onEnter() {},
+  onExit() {},
+  onDone() {},
+  onInit() {
+    this.start();
+  },
+});
+HelloWorld.init();

package/index.js

@@ -0,0 +1,528 @@
+// Copyright (c)2021 Quinn Michaels
+// Distributed under the MIT software license, see the accompanying
+// file LICENSE.md or http://www.opensource.org/licenses/mit-license.php.
+const {EventEmitter} = require('events');
+class Deva {
+  constructor(opts) {
+    opts = opts || {};
+    this._uid = this.uid();                             // the unique id assigned to the agent at load
+    this.state = 'offline';                             // current state of agent.
+    this.active = false;                                // the active/birth date.
+    this.security = false;                              // inherited Security features.
+    this.config = opts.config || {};                    // local Config Object
+    this.events = opts.events || new EventEmitter({});  // Event Bus
+    this.lib = opts.lib || {};                          // used for loading library functions
+    this.agent = opts.agent || false;                   // Agent profile object
+    this.client = opts.client || false;                 // Client profile object
+    this.devas = opts.devas || {};                      // Devas which are loaded
+    this.vars = opts.vars || {};                        // Variables object
+    this.listeners = opts.listeners || {};              // local Listeners
+    this.modules = opts.modules || {};                  // 3rd Party Modules
+    this.func = opts.func || {};                        // local Functions
+    this.methods = opts.methods || {};                  // local Methods
+    this.maxListeners = opts.maxListenners || 0;        // set the local maxListeners
+
+    for (var opt in opts) {
+      if (!this[opt]) this[opt] = opts[opt];            // set any remaining opts to this.
+    }
+
+    this.cmdChr = '!';
+    this.askChr = '#';
+    this.inherit = ["events", "config", "lib", "security", "client"];
+    this.bind = ["listeners", "methods", "func", "lib", "security", "agent", "client"];
+    this.states = {
+      offline: 'OFFLINE',
+      init: 'INITIALIZE',
+      start: 'START',
+      stop: 'STOP',
+      enter: 'ENTER',
+      exit: 'EXIT',
+      done: 'DONE',
+      wait: 'WAITING',
+      ask: 'ASK',
+      question: 'QUESTION',
+      answer: 'ANSWER',
+      error: 'ERROR',
+      security: 'SECURITY',
+      medic: 'MEDICAL',
+    };
+    this.messages = {
+      offline: 'AGENT OFFLINE',
+      loaded: 'DEVAS LOADED',
+      stopped: 'DEVAS STOPPED',
+      notext: 'NO TEXT',
+    }
+  }
+
+  // set the state of the agent with the passed value to match the valid keys.
+  // this will also talk a global state event with the agent data and state.
+  // then security can watch all the glorious state change events.
+  set _state(st) {
+    this.state = this.states[st];
+    this.talk(`state`,{
+      uid: this.uid(),
+      agent: this.agent,
+      state: this.state,
+      created: Date.now(),
+    });
+    this.prompt(this.state);
+  }
+  // Called from the init function to bind the elements defined in the this.bind variable.
+  // the assign bind ensures that the *this* scope is available to child elements/functions.
+  _assignBind() {
+    return new Promise((resolve, reject) => {
+      try {
+        this.bind.forEach(bind => {
+          if (this[bind]) for (let x in this[bind]) {
+            if (typeof this[bind][x] === 'function') {
+              this[bind][x] = this[bind][x].bind(this);
+            }
+          }
+        });
+        // bind translate
+        const translate = this.agent && this.agent.translate && typeof this.agent.translate === 'function';
+        if (translate) this.agent.translate = this.agent.translate.bind(this);
+        // bind parser
+        const parse = this.agent && this.agent.parse && typeof this.agent.parse === 'function';
+        if (parse) this.agent.parse = this.agent.parse.bind(this);
+      }
+      catch (e) {
+        return reject(e);
+      }
+      finally {
+        return resolve();
+      }
+    });
+  }
+
+  // Called from the init function to assign the listeners to various states.
+  // when the listener fires it will call the associated named function.
+  _assignListeners() {
+    return new Promise((resolve, reject) => {
+      try {
+        // set the default listeners for the states of the agent.
+        for (let state in this.states) {
+          this.events.on(`${this.agent.key}:${state}`, packet => {
+            return this[state](packet);
+          })
+        }
+        // set the assigned listeners for the agent.
+        for (let listener in this.listeners) {
+          this.events.on(listener, packet => {
+            return this.listeners[listener](packet);
+          })
+        }
+      }
+      catch (e) {
+        return reject(e);
+      }
+      finally {
+        return resolve();
+      }
+    });
+  }
+
+  // Some elements will inherit the data of the parent. this object will loop over
+  // any children data that theis deva has and assign the inherited information.
+  _assignInherit() {
+    return new Promise((resolve, reject) => {
+      try {
+        for (let d in this.devas) {
+          this.inherit.forEach(inherit => {
+            this.devas[d][inherit] = this[inherit];
+          });
+        }
+      }
+      catch (e) {
+        return reject(e);
+      }
+      finally {
+        return resolve();
+      }
+    });
+  }
+
+  // General handler for when a method is NOT found from a user command.
+  _methodNotFound(packet) {
+    packet.a = {
+      agent: this.agent || false,
+      client: this.client || false,
+      text: `${packet.q.meta.method} is NOT a valid method.`,
+      meta: {
+        key: this.agent.key,
+        method: packet.q.meta.method,
+      },
+      created: Date.now(),
+    };
+    return packet;
+  }
+
+  // A simple interface to generate a unique id for the agent. As agents will
+  // quite oftne have to key their transactions. This will provide all agents
+  // with the same key generator which can also be modified to link into a remote
+  // generator or some other solution if needed.
+  uid() {
+    const min = Math.floor(Date.now() - (Date.now() / Math.PI));
+    const max = Math.floor(Date.now() + (Date.now() * Math.PI));
+    return Math.floor(Math.random() * (max - min)) + min;
+  }
+
+  // The talk interface binds to the events emitter to allow agents to perform a
+  // this.talk(*) feature.
+  talk(evt, resource=false) {
+    return this.events.emit(evt, resource);
+  }
+
+  // the listen interface binds to the event emitter to allow agents to listen
+  // this.listen(*) feature.
+  listen(evt, callback) {
+    return this.events.on(evt, callback);
+  }
+
+  // Instances where listening for only one unique keyed event is required
+  // this interface is provided for the this.once(*) feature.
+  once(evt, callback) {
+    return this.events.once(evt, callback);
+  }
+
+  // where an agent needs to ignore events or remove a lisatener this interface
+  // serves the this.ignore(*) feature.
+  ignore(evt, callback) {
+    return this.events.removeListener(evt, callback);
+  }
+
+  // Used when loading a Deva dynamically into the current set.
+  load(opts) {
+    this.devas[opts.key] = opts;
+    // inherit the data to the new deva.
+    this.inherit.forEach(inherit => {
+      this.devas[agent][inherit] = this[inherit];
+    });
+
+    return Promise.resolve();
+  }
+
+  // Used when unloading a deva dynamically from the set.
+  unload(agent) {
+    delete this.devas[agent];
+    return Promise.resolve();
+  }
+
+  // Askign a question to another deva in the set besides itself. If the question
+  // interface detects the action is to ask another deva a question with
+  // this.askChr variable match. Then an answer packet is generated and the
+  // deva is asked to process the question asked and return it's proper data set
+  // from the requested method.
+  // this is an event function that relies on talk/listen
+
+  ask(packet) {
+    if (!this.active) return Promise.resolve(this.messages.offline);
+
+    this._state = this.states.ask;
+    packet.a = {
+      agent: this.agent || false,
+      client: this.client || false,
+      meta: {
+        key: this.agent.key,
+        method: packet.q.meta.method,
+        params: packet.q.meta.params,
+      },
+      text: false,
+      html: false,
+      data: false,
+      created: Date.now(),
+    };
+
+    try {
+      if (this.methods[packet.q.meta.method] === undefined) {
+        return setImmediate(() => {
+          packet.a.text = `INVALID METHOD (${packet.q.meta.method})`;
+          this.talk(`${this.agent.key}:ask:${packet.id}`, packet);
+        });
+      }
+
+      // The method is parsed and depending on what method is asked for it returns
+      // the response based on the passed through packet.
+      this.methods[packet.q.meta.method](packet).then(result => {
+        if (typeof result === 'object') {
+          packet.a.text = result.text || false;
+          packet.a.html = result.html || false;
+          packet.a.data = result.data || false;
+        }
+        else {
+          packet.a.text = result;
+        }
+        // talk back to the once event with the ask key.
+        this.talk(`${this.agent.key}:ask:${packet.id}`, packet);
+      }).catch(err => {
+        this._state = this.states.error;
+        // If the ask method fails then a reject error is returned from the this.error
+        // interface.
+        this.talk(`${this.agent.key}:ask:${packet.id}`, {error:err.toString()});
+        return this.error(err, packet);
+      })
+    }
+    catch (e) {
+      this._state = this.states.error;
+      // if any error is caught in the processing of the ask then it returns and
+      // executes the this.error(*) interface.
+      this.talk(`${this.agent.key}:ask:${packet.id}`, {error:e.toString()});
+      return this.error(e, packet)
+    }
+    // now when we ask the meta params[0] should be the method
+  }
+
+  // general question interface.
+  // accepts two arguments a *TEXT* and *DATA* object.
+  // if the question being asked is a simple text command then
+  // this.question('#*agent.key *method* *text*')
+  // if the question is a data object
+  // this.question('#*agent.key* *method* *properties*', {*data*});
+  question(TEXT=false, DATA=false) {
+    this._state = this.states.question;
+    const id = this.uid();
+    const t_split = TEXT.split(' ');
+    const isAsk = t_split[0].startsWith(this.askChr) ? t_split[0].substring(1) : false;
+    const isCmd = t_split[0].startsWith(this.cmdChr) ? t_split[0].substring(1) : false;
+    // Format the packet for return on the request.
+    const orig = TEXT;
+    const data = DATA;
+    const packet = {
+      id,
+      q: {},
+      a: {},
+      created: Date.now(),
+    };
+
+    let text = TEXT,
+        params = false,
+        method = 'question',
+        key = this.agent.key;
+
+    return new Promise((resolve, reject) => {
+      if (!TEXT) return reject(this.messages.notext);
+      try {
+        if (!this.active) return reject(this.messages.offline);
+
+        // *: send just a string of text
+        // !: send a command to the local agent
+        // #: ask another agent a question
+        // #agent method:param1:param2 with text strings for proccessing
+        // !method param:list:parse for the local agent
+        // if is an ask then we format one way
+        if (isAsk) {
+          params = t_split[1] ? t_split[1].split(':') : false;
+          method = params[0];
+          text = t_split.slice(2).join(' ').trim();
+          key = isAsk;
+        }
+        else if (isCmd) {
+          params = t_split[1] ? t_split[1].split(':') : false;
+          method = isCmd;
+          text = t_split.slice(1).join(' ').trim()
+        }
+
+        packet.q = {
+            agent: this.agent || false,
+            client: this.client || false,
+            meta: {
+              key,
+              orig,
+              method,
+              params,
+            },
+            text,
+            data,
+            created: Date.now(),
+        }
+
+        // if is a command then we format another way
+        // if the user asks a question to another deva '#' then issue the talk/once
+        // event combination.
+        if (isAsk) {
+          this._state = this.states.ask;
+          this.talk(`${isAsk}:ask`, packet);
+          this.once(`${isAsk}:ask:${packet.id}`, answer => {
+            return resolve(answer);
+          });
+        }
+        // if the user sends a local command '$' then it will ask of the self.
+        else {
+          if (typeof this.methods[method] !== 'function') return resolve(this._methodNotFound(packet));
+          this.methods[method](packet).then(result => {
+            const text = typeof result === 'object' ? result.text : result;
+            const html = typeof result === 'object' ? result.html : result;
+            const data = typeof result === 'object' ? result.data : false;
+            packet.a = {
+              agent: this.agent || false,
+              client: this.client || false,
+              meta: {
+                key: this.agent.key,
+                method,
+              },
+              text,
+              html,
+              data,
+              created: Date.now(),
+            };
+            this._state = this.states.answer;
+            return resolve(packet);
+          }).catch(err => {
+            return this.error(err, packet);
+          });
+        }
+      }
+      catch(e) {
+        return this.error(e);
+      }
+    });
+  }
+
+
+  // The main init interface where the chain begins.
+  // a set of options is passed into the init function which is the configuration
+  // object. from this opts object the system is built. After the opts object is processed
+  // the inherit is assigned and then bind then listners then
+  // opts: The options object containing the necessary vaules to build a Deva.
+  init() {
+    // set client
+    this._state = this.states.init;
+    return new Promise((resolve, reject) => {
+      this.events.setMaxListeners(this.maxListeners);
+      this._assignInherit().then(() => {
+        return this._assignBind();
+      }).then(() => {
+        return this._assignListeners();
+      }).then(() => {
+        return this.onInit ? this.onInit() : this.start();
+      }).then(started => {
+        return resolve(started)
+      }).catch(err => {
+        return reject(err);
+      });
+    });
+  }
+
+  // Interface for unified error reporting within all devas.
+  // this.error(*error*, *packet*) can be issued at time of any error.
+  // e: is the error to pass into the interface.
+  // packet: the packet that caused the error.
+  error(err,packet=false,reject=false) {
+    this._state = 'error';
+    // broadcast a global uniform error event.
+    this.talk('error', {
+      id: this.uid(),
+      agent: this.agent,
+      client: this.client,
+      error: err.toString('utf8'),
+      data: packet,
+      created: Date.now(),
+    });
+    // call the onError if there is a logcal one.
+    // if there is no local error return a promise reject.
+    if (this.onError) return this.onError(err, packet, reject);
+    return reject ? reject(err) : false;
+  }
+
+  // start the deva then return the 'onStart' function.
+  start() {
+    if (this.active) return;
+    this._state = 'start';
+    this.active = Date.now();
+    return this.onStart ? this.onStart() : this.enter();
+  }
+
+  // stop teh deva then return the onStop function.
+  stop() {
+    if (!this.active) return Promise.resolve(this.messages.offline);
+    this.active = false;
+    this._state = 'stop';
+    return this.onStop ? this.onStop() : this.exit();
+  }
+
+  // enter the deva then return the onEnter function.
+  enter() {
+    if (!this.active) return Promise.resolve(this.messages.offline);
+    this._state = 'enter';
+    return this.onEnter ? this.onEnter() : this.done(this.state)
+  }
+
+  // exit the deva then return the onExit function.
+  exit() {
+    if (!this.active) return Promise.resolve(this.messages.offline);
+    this._state = 'exit';
+    return this.onExit ? this.onExit() : this.done(this.state)
+  }
+
+  // set the deva as done then return the oDone function.
+  done(msg=false) {
+    if (!this.active) return Promise.resolve(this.messages.offline);
+    this._state = 'done';
+    msg = msg ? msg : this.state;
+    return this.onDone ? this.onDone() : Promise.resolve({msg,agent:this.agent})
+  }
+
+  // interface to return the status of the current deva with the time/date requested.
+  status(addtl=false) {
+    if (!this.active) return Promise.resolve(this.messages.offline);
+    const id = this.uid();
+    const dateFormat = new Intl.DateTimeFormat('en-US', { dateStyle: 'medium', timeStyle: 'medium' }).format(this.active);
+    let text = `${this.agent.name} is ONLINE since ${dateFormat}`;
+    if (addtl) text = text + `\n${addtl}`;
+    return Promise.resolve({text});
+  }
+
+  // universal prompt emitter
+  prompt(text) {
+    this.talk('prompt', {text, prompt:this.agent.prompt});
+  }
+
+  // universal hash builder
+  hash(packet) {
+    if (!this.vars.hash) this.vars.hash = '0x';
+    // setup basic hashing
+    // what type of hash depends on param 1
+    return new Promise((resolve, reject) => {
+      if (!packet) return reject('NO PACKET');
+      const params = packet.q.text.split(' ');
+      const hashType = params[0] ? params[0] : 'view';
+      switch (hashType) {
+        case 'clear':
+          this.vars.hash = '0x';
+          break;
+        case 'add':
+          this.vars.hash = `${this.vars.hash}${params[1]}`;
+          break;
+      }
+      return resolve({
+        text:this.vars.hash,
+        html:`<div class="hash">${this.vars.hash}</div>`
+      });
+    });
+  }
+  // initDeva interface is to initialize devas that this deva is a parent of.
+  // This feature allows a Deva to be a parent of a parent of a parent etc....
+  initDevas() {
+    return new Promise((resolve, reject) => {
+      const devas = [];
+      for (let x in this.devas) {
+        devas.push(this.devas[x].init());
+      }
+      Promise.all(devas).then(() => {
+        return resolve(this.messages.loaded);
+      }).catch(reject);
+    });
+  }
+  stopDevas() {
+    return new Promise((resolve, reject) => {
+      const devas = [];
+      for (let x in this.devas) {
+        devas.push(this.devas[x].stop());
+      }
+      Promise.all(devas).then(() => {
+        return resolve(this.messages.stopped);
+      }).catch(reject);
+    });
+  }
+}
+module.exports = Deva;

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@indra.ai/deva",
+  "version": "1.0.27",
+  "description": "The Deva Core",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/indraai/deva.git"
+  },
+  "keywords": [
+    "indra",
+    "deva",
+    "ai"
+  ],
+  "author": "Quinn Michaels",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/indraai/deva/issues"
+  },
+  "homepage": "https://github.com/indraai/deva#readme",
+  "eslintConfig": {
+    "parserOptions": {
+      "ecmaVersion": 6
+    }
+  },
+  "engines": {
+    "npm": ">=6.0.0",
+    "node": ">=10.0.0"
+  },
+  "dependencies": {}
+}