this.me 2.4.3 → 2.4.5

package/README.md

@@ -2,6 +2,7 @@
 
 # .me Suite - Your AI Playground
 For every recursive action, there's a repercussion.
+**Docs:** [this.me](https://www.neurons.me/this-me)
 
 ```
 npm install this.me
@@ -10,14 +11,37 @@ npm install this.me
 ### Conceptual Flow:
 
 - [ ] Set up your context with [this.me.](https://www.npmjs.com/package/this.me)
+
 - [ ] Create a neural network using [neurons.me](https://www.neurons.me).
+
 - [ ] Define the data you'd like your neural network to recognize or process with [this.](https://www.neurons.me/this) modules.
+
 - [ ] Use [this.be](https://www.npmjs.com/package/this.be) to maintain a state or context, - watching over  [This](https://www.neurons.me/this) and any other states you define for example.
+
 - [ ] Define desired status and handlers, [be.this](https://www.npmjs.com/package/be.this).
+
 - [ ] Keep [i.mlearning](https://www.npmjs.com/package/i.mlearning).
 
-### Dependencies:   
+  
 
+## Setting up your Context. 	👋🏻👋🏼👋🏽👋🏾👋🏿
+Defining the environment and context in which your code runs, especially when you're interacting with intelligent agents or services like me.
+Having a clear declaration of the environment and the context can have a series of implications for security, interoperability, and clarity. Let's delve into the importance of such declarations:
+
+### Security Context:
+Defining the environment ensures that both the user and the IA have a clear understanding of the boundary within which interactions take place.
+Explicitly stating the environment can prevent unintended cross-boundary actions. For instance, without a clear declaration, an IA might access files or services that are beyond its permitted scope, leading to potential security vulnerabilities.
+A well-defined environment acts as a sandbox that can restrict unauthorized or unintended activities. For instance, browsers use a similar principle to run JavaScript in a sandboxed environment for security reasons.
+
+**Interoperability:**
+As the ecosystem of software and services becomes increasingly diverse, ensuring your code can interact smoothly with other systems becomes crucial.
+Declaring the environment or context helps ensure that all systems are on the "same page". For example, if an IA knows it's operating within the ".me" context, it can adjust its behavior, assumptions, and dependencies accordingly.
+
+**Auditability and Compliance:**
+For industries or applications where audit trails and compliance are important, having a clear declaration of the environment ensures that every interaction and operation can be traced back to a defined context.
+Such clear demarcations can aid in forensic analysis if something goes wrong or if there's a need to understand the context of an interaction.
+
+### Dependencies:   
 ```json
 "dependencies": {
     "be.this": "^1.1.3",

package/main.js

@@ -2,12 +2,15 @@
 //main.js
 const { exec } = require("child_process");
 const path = require("path");
+const crypto = require('crypto');
+const fs = require('fs');
 const args = process.argv.slice(2);
 const neurons = require("neurons.me");
 const cleaker = require("cleaker");
 const Atom = require("this.atom");
 // Your CLI logic goes here, display welcome message, handle other commands, etc.
-console.log(`
+function displayWelcomeMessage() {
+  console.log(`
           ___________                                 
          [------------]                              
          | .--------. |                             
@@ -24,34 +27,100 @@ console.log(`
 Welcome to .me - Your AI Playground
 give me one sec please...
 `);
-
-if (args[0] === 'viewer') {
-  // Create an instance of the Atom class
+};
+//ATOMS ELECTRONS AND PARTICLES IN PROGRESS...
+//WE WILL RUN OUR NODE PROCCESSES IN ELECTRON WINDOWS AND EACH ATOM WILL HOLD ELECTRONS WHICH HOLDS THE PROCESSES
+//THUS WE WILL KNOW HOW CHARGED AN ATOM IS BY THE NUMBER OF ELECTRONS IT HAS AND HOW MANY PROCESSES IT IS RUNNING.
+//WE WILL ALSO BE ABLE TO SEE THE PROCESSES RUNNING IN EACH ELECTRON AND THE ATOMS THAT ARE RUNNING THEM.
+function handleViewerCommand() {
   const atom = new Atom();
-  // Create a new Electron window with viewer.html inside
-  atom.createElectron('viewer', { width: 800, height: 600, viewFile: path.resolve(__dirname, 'viewer.html') });
-  // Show the Electron window
+  atom.createElectron('viewer', {
+      width: 800,
+      height: 600,
+      viewFile: path.resolve(__dirname, 'viewer.html')
+  });
   atom.showElectron('viewer');
 }
-
-if (args[0] === 'atom') {
-  // Create an instance of the Atom class
+function handleAtomCommand() {
   const atom = new Atom();
-  // Create Electrons for Atom 1
-  atom.createElectron('electron1', { width: 800, height: 600, viewFile: './view1.html' });
-  atom.createElectron('electron2', { width: 600, height: 400, viewFile: './view2.html' });
-  // Create Electrons for Atom 2
-  atom.createElectron('electron3', { width: 1000, height: 800, viewFile: './view3.html' });
-  // Show the Atom window with electrons
+  atom.createElectron('electron1', {
+      width: 800,
+      height: 600,
+      viewFile: './view1.html'
+  });
+  atom.createElectron('electron2', {
+      width: 600,
+      height: 400,
+      viewFile: './view2.html'
+  });
+  atom.createElectron('electron3', {
+      width: 1000,
+      height: 800,
+      viewFile: './view3.html'
+  });
   atom.showAtom();
 }
 
-module.exports = {
-  cleaker,
-  neurons,
-  Atom
-};
+//.. THIS SECTION IS FOR HASHING PURPOSES ...//
+/* Create a function that computes the hash of the @src directory.
+ 'hash-src') to handle hashing when the relevant command is passed to the script.*/
+ function getAllFilesFromSourceCode(directory) {
+  const entries = fs.readdirSync(directory, { withFileTypes: true });
+  const files = entries.filter(fileDirent => fileDirent.isFile()).map(fileDirent => path.join(directory, fileDirent.name));
+  const folders = entries.filter(folderDirent => folderDirent.isDirectory());
+  for (const folder of folders) {
+      files.push(...getAllFilesFromSourceCode(path.join(directory, folder.name)));
+  }
+  return files;
+}
+function hashSourceCode(directoryPath) {
+  // Ensure path is absolute
+  if (!path.isAbsolute(directoryPath)) {
+      throw new Error('Directory path must be absolute.');
+  }
+  // Get all files from the directory recursively
+  const allFiles = getAllFilesFromSourceCode(directoryPath);
+  // Read all file content and concatenate it
+  const allContent = allFiles.map(file => fs.readFileSync(file)).join('');
+  // Hash the content using SHA256 (or another hashing algorithm)
+  const hash = crypto.createHash('sha256').update(allContent).digest('hex');
+  return hash;
+}
 
+function HashSrc() {
+  try {
+      // Adjust this to the exact location of your @src directory
+      const srcDirPath = path.resolve(__dirname, '@src');
+      const hash = hashSourceCode(srcDirPath);
+      console.log(`Hash of @src directory: ${hash}`);
+  } catch (error) {
+      console.error('Error hashing @src directory:', error.message);
+  }
+}
 
+// Display the welcome message
+displayWelcomeMessage();
 
+// COMMAND HANDLERS
+switch(args[0]) {
+  case 'hash-src':
+        HashSrc();
+        break;
+  case 'viewer':
+      handleViewerCommand();
+      break;
+  case 'atom':
+      handleAtomCommand();
+      break;
+  default:
+      console.log('Command not recognized. Use "viewer" or "atom" as arguments.');
+}
 
+module.exports = {
+  cleaker,
+  neurons,
+  Atom,
+  getAllFilesFromSourceCode,
+  hashSourceCode,
+  HashSrc
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "this.me",
-  "version": "2.4.3",
+  "version": "2.4.5",
   "description": "This.me should This.be",
   "bin": {
     ".me": "./main.js"