this.me 2.1.5

package/README.md

@@ -0,0 +1,99 @@
+# **me** CLI 
+THIS IS NOT A STABLE VERSION, I AM DOING SOME CHANGES WILL UPLOAD THE NEW SETUP, IT HAS LOTS OF CHANGES IN THE STRUCTURE AND IT MAKES EVERYTHING EASIER.
+THANKS, gracias amigos!
+The **me CLI** is the command-line interface that puts you in control of managing your neural networks with ease using the powerful neurons.me library. With just a few simple commands, you can create neurons, build neural networks, interact with Cleaker, and harness the capabilities of Netget, all from the comfort of your terminal.
+
+### Installation
+
+#### Option 1 Global
+
+To empower yourself with the **me CLI**, simply install it globally using npm. Open your terminal and enter the following command:
+
+```
+npm install -g @sui.gn/me
+```
+
+**Pro-tip:** Depending on your system, you might need to use sudo with the above command for global installation.
+
+**Running CLI Commands Globally**: If you have installed the CLI globally, and you run the CLI command from any directory in your terminal, it will execute the globally installed version of the CLI. The local dependency within the project will not affect the global CLI in this case.
+
+#### Option 2 Local (Recommended)
+
+```bash
+# Installing the CLI as a dev dependency in the project
+npm install --save-dev @sui.gn/me
+
+# Using the CLI
+npx .me command --option value
+```
+
+**Running CLI Commands Locally**: If you have the CLI installed as a local dependency within a specific project, you have two options to run the CLI command:
+
+a. Using `npx`: The `npx` command is a utility that comes with npm and allows you to run locally installed Node.js packages. If you run the CLI command using `npx`, it will execute the locally installed version of the CLI, and the globally installed version will be ignored.
+
+### Getting Started
+
+Once installed, the me CLI becomes your trusted companion. Just type me to unlock a world of possibilities.
+
+### Create Your First Neuron
+To craft a neuron tailored to your needs, use the newNeuron command with various options. For example:
+
+```
+npx .me newNeuron -n MyNeuron -d 2023-07-28 -t "12:00 PM" -c blue -a "x => x * 2" -w "[0.5, 0.3, -0.1]" -b 0.2
+```
+
+# CLI Command Structure:
+We can define a set of commands that users can use to interact with the neurons.me library. 
+For example:
+
+For classes and methods in the `neurons.me` library:
+
+- `.me newNeuron`: Create a new neuron with custom properties.
+- `.me newNeuralNetwork`: Create a new neural network.
+
+For defacto modules, the `me` prefix is combined with the module name.
+
+The `.me` CLI simplifies and streamlines interactions with `neurons.me` and its defacto modules, making it easier for users to manage neural networks and leverage powerful functionalities.
+
+### Create a new neuron:
+```
+npx .me createNeuron
+```
+
+```
+npx .me new NeuralNetwork();
+```
+
+### Access netget functionality:
+```
+npm .me netget get
+npm .me netget ws
+```
+# CLI Options:
+For each command, we can provide options that users can use to customize the behavior. For example:
+--name: Specify a custom name for the neuron or neural network.
+--weights: Provide custom weights for the neuron.
+--bias: Specify a custom bias for the neuron.
+--activation: Set a custom activation function for the neuron.
+
+# Modularity and Extensibility:
+We can design the CLI to be modular and extensible, allowing users to add custom modules and features easily. For example, users can create their own modules and add them to the defacto module in neurons.me for easy integration into the CLI.
+# Usage and Usefulness:
+The CLI provides a simple and intuitive way for users to interact with the neurons.me library without the need to write code directly. It allows users to create complex neural networks with custom configurations easily. The interactive input and customizable options make it versatile and suitable for various use cases.
+# Flexibility and Automation:
+Users can use the CLI to automate the process of creating and configuring neural networks. They can write scripts that leverage the CLI commands and options to create and manage multiple neural networks programmatically.
+# Memory Storage:
+The neurons.me library uses Map objects to store and manage instances of neurons, layers, and neural networks. Each type of entity (neuron, layer, and neural network) has its own Map, and when a new instance is created, it is added to the corresponding Map.
+For example, when the user executes the command create neuron, a new instance of the Neuron class is created, and it gets added to the Neuron.map. Similarly, when the user creates a layer using the create layer command, the new layer instance is added to the Layer.map.
+# Lifecycle and Cleaning:
+The created entities will remain in memory as long as the Node.js process is running. When the Node.js process is terminated (e.g., by closing the terminal or stopping the application), the memory will be freed, and all the entities stored in memory will be cleaned up by the garbage collector.
+If you want to persist the entities beyond the lifetime of the Node.js process, you would need to implement a mechanism to store them in a database or a file system.
+# Accessing and Deleting Entities:
+Since the created entities are stored in Map objects within the neurons.me library, you can access them later by using the respective get methods of the Map objects.
+For example, to access a specific neuron with ID 1, you can use Neuron.map.get(1). Similarly, to access a specific layer with ID 2, you can use Layer.map.get(2).
+
+To delete an entity, you can use the delete method of the Map objects. For example, to delete a neuron with ID 1, you can use Neuron.map.delete(1).
+
+Keep in mind that when an entity is deleted from the Map, the corresponding JavaScript object will be eligible for garbage collection, and its memory will be freed once the garbage collector runs.
+
+It's important to note that the neurons.me library may have additional internal mechanisms to manage the lifecycle of entities, but the general idea is that created entities are stored in memory during the Node.js process's lifetime and can be accessed and deleted using the appropriate methods.

package/compareit.js

@@ -0,0 +1,47 @@
+// ./src/NeuronsHandler.js
+const neurons = require('neurons.me');
+const { logError } = require('@sui.gn/me/src/errorHandler');
+const { showMenu } = require('./utils');
+const prompt = (rl, question) => new Promise((resolve) => rl.question(question, resolve));
+//neuron handler
+module.exports = (rl) => {
+  // Other functions...
+
+  const neuronConfig = async (rl, neuron, updateNeuronProperties, cloneNeuron, showMenu) => {
+    // Other code...
+    switch (action.trim()) {
+      case '1':
+        await updateNeuronProperties(neuron, rl, cloneNeuron, showMenu);
+        break;
+      case '2':
+        await cloneNeuron(neuron, rl, updateNeuronProperties, showMenu);
+        break;
+      case '3':
+        showNeuronMenu();
+        break;
+      case '4':
+        showMenu(rl, showNeuronMenu);
+        break;
+      default:
+        console.log('Invalid action. Back to Neuron Menu.');
+        showNeuronMenu();
+    }
+  };
+
+  const createNeuron = async (rl, updateNeuronProperties, cloneNeuron, showMenu) => {
+    // Other code...
+    await neuronConfig(rl, neuron, updateNeuronProperties, cloneNeuron, showMenu);
+  };
+
+  // Other functions...
+
+  return {
+    showNeuronMenu,
+    promptNeuronConfig,
+    listAllNeurons,
+    createNeuron,
+    neuronConfig,
+    updateNeuronProperties,
+    cloneNeuron
+  };
+}

package/docs/design.md

@@ -0,0 +1,47 @@
+CLI commands:
+
+Create a new neuron:
+Usage: me newNeuron [options]
+
+Options:
+  -n, --name <name>              Specify a custom name for the neuron
+  -d, --date <date>              Specify a custom date for the neuron
+  -t, --time <time>              Specify a custom time for the neuron
+  -c, --color <color>            Specify a custom color for the neuron
+  -a, --activation <function>    Specify a custom activation function for the neuron
+  -w, --weights <weights>        Specify custom weights for the neuron
+  -b, --bias <bias>              Specify a custom bias for the neuron
+  -h, --help                     display help for command
+
+Login:
+Usage: me login [options]
+
+Options:
+  -u, --username <username>      Enter your username
+  -p, --password <password>      Enter your password
+  -h, --help                     display help for command
+
+Interact with cleaker:
+Usage: me cleaker <command> [options]
+
+Commands:
+  register                       Register a new user on cleaker.me
+  login                          Login to your cleaker.me account
+  publishModel                   Publish a neural network model to cleaker.me
+  --help                         display help for command
+
+Create a new neural network:
+Usage: me newNeuralNetwork [options]
+
+Options:
+  -h, --help                     display help for command
+
+Access netget functionality:
+Usage: me netget <command> [options]
+
+Commands:
+  get                            Get data using netget
+  ws                             Establish a WebSocket connection using netget
+  --help                         display help for command
+
+These commands provide a clear and concise way for users to interact with the neurons.me CLI. The options allow users to customize the properties of neurons and neural networks as needed. The cleaker and netget commands are organized under their respective subcommands for easy access to their functionalities.

package/main.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+//main entry point to .me suite. Happy bizarre coding....
+const readline = require('readline');
+const neurons = require('neurons.me');
+const cleakerShell = require('cleaker/shell');
+const Menu = require('@sui.gn/me/src/utils');
+// Other imports ...
+console.log(`
+          ___________                                 
+         [------------]                              
+         | .--------. |                             
+         | |01010101| |       __________              
+         | |11010101| |      /__________\             
+[--------|  --------  |------|   --*--  |-------]
+|        [----_-.-----]      |o ======  |       | 
+|       ______|_|_______     |__________|       | 
+|      /  %%%%%%%%%%%%  \                       | 
+|     /  %%%%%%%%%%%%%%  \                      | 
+|     ^^^^^^^^^^^^^^^^^^^^                      | 
+[---------------------------------.me-----------]
+-^^^^^^^^zzzz...
+Welcome to .me - Your AI Playground
+`);
+// .me Main entry function
+function main() {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  mainMenu(rl);
+  rl.setPrompt('Select module (.me)> ');
+  rl.prompt();
+  rl.on('line', (input) => {
+    switch (input.trim()) {
+      case '1':
+        const neuronsShell = neurons.shell(rl); // Call neurons.shell to get the object
+        neurons.shell(rl).init(); // initiate neurons.me
+        break;
+      case '2':
+        cleakerShell(rl);
+        break;
+     // Add other cases...
+     case '/q':
+        rl.close();
+        break;
+      default:
+        console.log('Invalid option. Please choose a valid module.');
+        rl.prompt();
+    }
+    }).on('close', () => {
+    console.log('Exiting .me');
+    process.exit(0);
+  });
+}   
+function mainMenu(rl) {
+    console.log('\nChoose a module to get started:');
+    console.log('1. neurons.me - Manage neural networks');
+    console.log('2. cleaker - Work with Cleaker application');
+    console.log('\ntype /q to exit');
+    rl.prompt();
+  }
+// NEURONS.ME SECTION
+function neuronsModule(rl) {
+  class NeuronsMeApp {
+    constructor() {
+      this.rl = rl;
+      this.currentMenu = new neuronsme_MainMenu(this);
+      this.currentMenu.display(); // Display the main menu
+    }
+    // ... Rest of your neurons.me related code
+  }
+
+  class neuronsme_MainMenu extends Menu {
+    // ... Your existing code for the neurons menu
+  }
+  
+  // Other neurons classes...
+
+  const neurons_me_app_init = new NeuronsMeApp();
+  neurons_me_app_init.start();
+}
+// CLEAKER SECTION
+function cleakerModule(rl) {
+  // Implement the cleaker module here
+}
+main();

package/mainoLD.js

@@ -0,0 +1,162 @@
+const readline = require('readline');
+const neurons = require('neurons.me');
+const { logError } = require('./src/errorHandler');
+const Menu = require('./src/utils'); // Import Menu class
+const NeuronsHandler = require('@sui.gn/me/src/NeuronsHandler');
+const NeuralNetworksHandler = require('@sui.gn/me/src/NeuralNetworksHandler');
+const LayersHandler = require('@sui.gn/me/src/LayersHandler');
+
+class MainApp {
+  constructor() {
+    this.rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    this.displayMainMenu();
+  }
+
+  displayMainMenu() {
+    console.log('\nWelcome to .me CLI! Choose a module to get started:\n');
+    console.log('1. neurons - Manage neural networks');
+    console.log('2. cleaker - Work with Cleaker application');
+    console.log('3. v://     - Kind of like c path');
+    console.log('\ntype /q to exit');
+    this.rl.prompt();
+  }
+
+  start() {
+    this.rl.on('line', (input) => {
+      switch (input.trim()) {
+        case '1':
+          neuronsHandler.run(this.rl); // Run neurons module
+          break;
+        // Handle other cases...
+      }
+    }).on('close', () => {
+      console.log('Exiting .me');
+      process.exit(0);
+    });
+  }
+}
+
+const app = new MainApp();
+app.start();
+
+
+
+//NEURONS.ME SECTION
+class neuronsme_MainMenu extends Menu {
+  constructor(app) {
+    super(app.rl);
+    this.app = app; // Store the reference to the main app
+  }
+  async display() {
+    console.log('\nRunning .me! Your AI playground.\n');
+    console.log('┌──────────────────────────────────────────┐');
+    console.log('│                MAIN MENU                │');
+    console.log('└──────────────────────────────────────────┘');
+    console.log('\ntype /q to exit:');
+    console.log('1. Neurons: Create, list, update, and delete neurons');
+    console.log('2. Neural Networks: Create, list, update, and delete neural networks');
+    console.log('3. Layers: Create, list, update, and delete layers');
+    console.log('4. Show Info...');
+    this.rl.prompt();
+  }
+  async handleInput(input) {
+    switch (input) {
+      case '/q':
+        this.rl.close();
+        break;
+      case '1':
+        this.currentMenu = new neuronsme_NeuronsMenu(this.rl);
+        break;
+      case '2':
+        this.currentMenu = new neuronsme_NeuralNetworksMenu(this.rl);
+        break;
+      case '3':
+        this.currentMenu = new neuronsme_LayersMenu(this.rl);
+        break;
+      case '4':
+        console.log('Showing information of neurons.me...');
+        console.log(neurons);
+        break;
+      default:
+        console.log('Invalid option. Please choose a valid menu option.');
+    }
+    this.currentMenu.display();
+  }
+}
+class neuronsme_NeuronsMenu extends Menu {
+  constructor(app) {
+    super(app.rl);
+    this.app = app; // Store the reference to the main app
+  }
+  async display() {
+    console.log('\nNeurons:');
+    console.log('0. Back to Home');
+    console.log('1. Create a new neuron');
+    console.log('2. List all neurons');
+    this.rl.prompt();
+  }
+  async handleInput(input) {
+    // Handle input based on the neurons menu options
+    // E.g., if input is '1', create a new neuron
+  }
+}
+class neuronsme_NeuralNetworksMenu extends Menu {
+  constructor(app) {
+    super(app.rl); // Pass the readline interface to the parent class
+    this.app = app; // Store the reference to the main app
+  }
+  async display() {
+    console.log('\nNeural Networks:');
+    console.log('0. Back to Home');
+    console.log('1. Create a new neural network');
+    console.log('2. List all neural networks');
+    this.rl.prompt();
+  }
+  async handleInput(input) {
+    // Handle input based on the neural networks menu options
+    // E.g., if input is '1', create a new neural network
+  }
+}
+class neuronsme_LayersMenu extends Menu {
+  constructor(app) {
+    super(app.rl); // Pass the readline interface to the parent class
+    this.app = app; // Store the reference to the main app
+  }
+  async display() {
+    console.log('\nLayers:');
+    console.log('0. Back to Home');
+    console.log('1. Create a new layer');
+    console.log('2. List all layers');
+    this.rl.prompt();
+  }
+  async handleInput(input) {
+    // Handle input based on the layers menu options
+    // E.g., if input is '1', create a new layer
+  }
+}
+
+class NeuronsMeApp {
+  constructor() {
+    this.rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    this.currentMenu = new neuronsme_MainMenu(this); // Pass the entire app instance
+    this.currentMenu.display(); // Display the main menu
+  }
+  start() {
+    this.rl.setPrompt('neurons.me> '); // Use 'this.rl'
+    this.rl.prompt();
+    this.rl.on('line', (input) => {
+      this.currentMenu.handleInput(input.trim());
+    }).on('close', () => {
+      console.log('Exiting .me');
+      process.exit(0);
+    });
+  }
+}
+const neurons_me_app_init = new NeuronsMeApp();
+neurons_me_app_init.start();

package/neurons.js

@@ -0,0 +1,4 @@
+const neurons = require('neurons.me');
+console.log(neurons.defacto.getModule('Cleaker'));
+console.log(neurons.scripts);
+console.log(neurons.NeuralNetwork);

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "this.me",
+  "version": "2.1.5",
+  "description": "CLI for managing the .me suite.",
+  "bin": {
+    ".me": "./index.js"
+  },
+  "main": "index.js",
+  "scripts": {
+    "test": "test"
+  },
+  "keywords": [
+    "me",
+    "DeepLearning",
+    "neuralnetworks",
+    "uthopias"
+  ],
+  "author": "suiGn",
+  "license": "MIT",
+  "dependencies": {
+    "neurons.me": "^2.2.9",
+    "cleaker": "^2.1.0",
+    "monadlisa": "^2.1.1",
+    "netget": "^2.1.6",
+    "v.path": "^2.1.3",
+    "@sui.gn/haiku": "1.2.2",
+    "@sui.gn/me": "2.1.3"
+  }
+}

package/src/LayersHandler.js

@@ -0,0 +1,29 @@
+const neurons = require('neurons.me');
+const { logError } = require('./errorHandler');
+module.exports = (rl) => {
+const showLayerMenu = () => {
+    console.log('\nLayers:');
+    console.log('1. Create a new layer');
+    console.log('2. List all layers');
+    console.log('3. Back to Main Menu');
+  };
+
+  const createLayer = () => {
+    // Logic to create a new layer
+    const layer = new neurons.Layer();
+    console.log('New layer created:', layer);
+    };
+
+    const listAllLayers = () => {
+        const allLayers = neurons.Layer.map;
+        if (allLayers.size === 0) {
+          console.log('No layers found.');
+        } else {
+          console.log('List of all layers:');
+          allLayers.forEach((layer, id) => {
+            console.log(`Layer ID: ${id}`, layer);
+          });
+        }
+      };
+      return { showLayerMenu, createLayer, listAllLayers };
+    };// end module exports

package/src/NeuralNetworksHandler.js

@@ -0,0 +1,32 @@
+const neurons = require('neurons.me');
+const { logError } = require('./errorHandler');
+const prompt = (question) => new Promise((resolve) => rl.question(question, resolve));
+
+module.exports = (rl) => {
+  const showNeuralNetworkMenu = () => {
+    console.log('\nNeural Networks:');
+    console.log('1. Create a new neural network');
+    console.log('2. List all neural networks');
+    console.log('3. Back to Main Menu');
+  };
+
+  const createNeuralNetwork = () => {
+    // Logic to create a new neural network
+    const neuralNetwork = new neurons.NeuralNetwork();
+    console.log('New neural network created:', neuralNetwork);
+  };
+
+  const listAllNeuralNetworks = () => {
+    const allNeuralNetworks = neurons.NeuralNetwork.map;
+    if (allNeuralNetworks.size === 0) {
+      console.log('No neural networks found.');
+    } else {
+      console.log('List of all neural networks:');
+      allNeuralNetworks.forEach((neuralNetwork, id) => {
+        console.log(`Neural Network ID: ${id}`, neuralNetwork);
+      });
+    }
+  };
+
+  return { showNeuralNetworkMenu, createNeuralNetwork, listAllNeuralNetworks };
+};

package/src/NeuronsHandler.js

@@ -0,0 +1,201 @@
+// ./src/NeuronsHandler.js
+const neurons = require('neurons.me');
+const { logError } = require('@sui.gn/me/src/errorHandler');
+const { showMenu } = require('./utils');
+const prompt = (rl, question) => new Promise((resolve) => rl.question(question, resolve));
+//neuron handler
+module.exports = (rl) => {
+const showNeuronMenu = () => {
+    console.log('\nNeurons:');
+    console.log('0. Back to Main Menu');
+    console.log('1. Create a new neuron');
+    console.log('2. List all neurons');
+    console.log('3. Editing Neurons');
+};
+const neuronConfig = async (rl, neuron, updateNeuronProperties, cloneNeuron) => {
+  console.log(`\nTailoring Neuron ID: ${neuron.processID}`);
+  console.log('0. Back to Main Menu');
+  console.log('1. Edit Properties.');
+  console.log('2. Clone this neuron');
+  console.log('3. Back to Neurons Menu');
+  const action = await prompt(rl, 'Choose an action: ');
+  switch (action.trim()) {
+    case '0':
+      showMenu(rl);
+      break;
+    case '1':
+      await updateNeuronProperties(neuron, rl, neuronConfig);
+      break;
+    case '2':
+      await cloneNeuron(neuron, rl, neuronConfig);
+      break;
+    case '3':
+      showNeuronMenu();
+      break;
+    default:
+      console.log('Invalid action. Back to Neuron Menu.');
+      showNeuronMenu();
+  }
+};
+const showNeuronProperties = (neuron) => {
+  console.log('\nSelected Neuron Properties:');
+  console.log('Selected Neuron ID:', neuron.processID);
+  console.log('Name:', neuron.name);
+  console.log('Date:', neuron.date);
+  console.log('Time:', neuron.time);
+  console.log('Color:', neuron.color);
+  console.log('Activation Function:', neuron.activationFunction.toString());
+  console.log('Weights:', neuron.weights);
+  console.log('Bias:', neuron.bias);
+};
+const promptNeuronConfig = async (rl, updateNeuronProperties, cloneNeuron, showMenu) => {
+  try {
+    const option = await prompt('Choose the ID of the neuron you want to access (or "back" to go back): ');
+    if (option.toLowerCase() === 'back') {
+      showNeuronMenu();
+    } else {
+      const neuronId = parseInt(option);
+      const neuron = neurons.Neuron.map.get(neuronId);
+      if (!neuron) {
+        console.log('Neuron with the specified ID not found.');
+        await promptNeuronConfig(updateNeuronProperties, cloneNeuron, showMenu);
+      } else {
+        await neuronConfig(neuron, updateNeuronProperties, cloneNeuron, showMenu);
+      }
+    }
+  } catch (error) {
+    logError(error);
+  }
+};
+const listAllNeurons = () => {
+  const allNeurons = neurons.Neuron.map;
+  if (allNeurons.size === 0) {
+    console.log('No neurons found.');
+  } else {
+    console.log('List of all neurons:');
+    allNeurons.forEach((neuron, id) => {
+      console.log(`${id}.`, neuron);
+    });
+  }
+  showMenu(rl, showNeuronMenu);
+};
+const createNeuron = async (rl, updateNeuronProperties, cloneNeuron, showMenu) => {
+  try {
+    const name = await prompt(rl, 'Enter the name of the neuron: ');
+    const color = await prompt(rl, 'Enter the color: ');
+    const activation = await prompt(rl, 'Enter the activation function: ');
+    const weights = await prompt(rl, 'Enter the weights: ');
+    const bias = await prompt(rl, 'Enter the bias: ');
+    const neuronOptions = {
+      name,
+      color,
+      activation,
+      weights,
+      bias,
+    };
+    const neuron = new neurons.Neuron(neuronOptions);
+    console.log('New neuron created:', neuron);
+    await neuronConfig(rl, neuron, updateNeuronProperties, cloneNeuron, showMenu);
+  } catch (error) {
+    logError(error);
+  }
+};
+const cloneNeuron = async (neuron, rl, updateNeuronProperties, showMenu) => {
+  try {
+    const name = await prompt(rl, 'Enter the name of the new neuron: ');
+
+    const clonedNeuron = new neurons.Neuron({
+      ...neuron,
+      name,
+    });
+
+    console.log('New neuron cloned:', clonedNeuron);
+    showNeuronActions(clonedNeuron, rl, updateNeuronProperties, cloneNeuron, showMenu);
+  } catch (error) {
+    logError(error);
+  }
+};
+const updateNeuronProperties = async (rl, neuron, cloneNeuron, showMenu) => {
+  try {
+    console.log('\nSelected Neuron Properties:');
+    showNeuronProperties(neuron);
+    const confirmation = await prompt(rl, '\nAre you sure you want to update properties? (yes/no): ');
+    if (confirmation.trim().toLowerCase() !== 'yes') {
+      console.log('Update canceled. Back to Neuron Menu.');
+      showNeuronActions(neuron, rl, updateNeuronProperties, cloneNeuron, showMenu);
+      return;
+    }
+    let updatedActivation = neuron.activationFunction.toString();
+    let updatedWeights = neuron.weights;
+    let updatedBias = neuron.bias;
+    while (true) {
+      console.log('\n1. Enter the new activation function');
+      console.log('2. Enter the new weights');
+      console.log('3. Enter the new bias');
+      console.log('4. Update all properties');
+      console.log('5. Save changes');
+      console.log('6. Back');
+      const propertyAction = await prompt(rl, '\nChoose an action: ');
+      switch (propertyAction.trim()) {
+        case '1':
+          updatedActivation = await prompt(rl, 'Enter the new activation function: ');
+          break;
+        case '2':
+          updatedWeights = await prompt(rl, 'Enter the new weights: ');
+          break;
+        case '3':
+          updatedBias = await prompt(rl, 'Enter the new bias: ');
+          break;
+        case '4':
+          const confirmUpdateAll = await prompt(rl, '\nAre you sure you want to update all properties? (yes/no): ');
+          if (confirmUpdateAll.trim().toLowerCase() === 'yes') {
+            updatedActivation = await prompt(rl, 'Enter the new activation function: ');
+            updatedWeights = await prompt(rl, 'Enter the new weights: ');
+            updatedBias = await prompt(rl, 'Enter the new bias: ');
+          }
+          break;
+        case '5':
+          neuron.activationFunction = eval(updatedActivation); // Converting the updatedActivation string back to a function
+          neuron.weights = updatedWeights;
+          neuron.bias = updatedBias;
+          console.log('\nUpdated Neuron Properties:');
+          neuronConfig(rl, neuron, updateNeuronProperties, cloneNeuron, showMenu);
+          const finalConfirmation = await prompt(rl, '\nDo you want to apply these changes? (yes/no): ');
+          if (finalConfirmation.trim().toLowerCase() !== 'yes') {
+            console.log('Changes not applied. Back to Neuron Menu.');
+          } else {
+            console.log('Neuron properties updated successfully.');
+          }
+          neuronConfig(rl, neuron, updateNeuronProperties, cloneNeuron, showMenu);
+          return;
+        case '6':
+          console.log('Update canceled. Back to Neuron Menu.');
+          neuronConfig(rl, neuron, updateNeuronProperties, cloneNeuron, showMenu);
+          return;
+        default:
+          console.log('Invalid action. Please choose a valid action.');
+      }
+    }
+  } catch (error) {
+    logError(error);
+  }
+};
+return {
+  showNeuronMenu,
+  promptNeuronConfig,
+  listAllNeurons,
+  createNeuron,
+  neuronConfig,
+  updateNeuronProperties,
+  cloneNeuron
+};
+}
+
+/*Input Validation: It would be better to add some form of input validation.
+ For example, when setting the weights or bias of a neuron,
+  you could check that the user's input is a valid number.
+Security: Be careful when using eval().
+ eval() evaluates a string of JavaScript code in the global context,
+  which can lead to security issues. If the string comes from an untrusted source, 
+  it can potentially run malicious code. If you need to convert a string to a function, 
+  consider safer alternatives.*/

package/src/errorHandler.js

@@ -0,0 +1,9 @@
+const logError = (error) => {
+    console.error('An error occurred:', error.message);
+    process.exit(1);
+  };
+  
+  module.exports = {
+    logError,
+  };
+  

package/src/utils.js

@@ -0,0 +1,17 @@
+//CLASSES
+class Menu {
+  constructor(rl) {
+    this.rl = rl;
+  }
+  prompt(question) {
+    return new Promise((resolve) => this.rl.question(question, resolve));
+  }
+  async display() {
+    throw new Error('Method display() must be implemented by subclass');
+  }
+  async handleInput(input) {
+    throw new Error('Method handleInput() must be implemented by subclass');
+  }
+}
+
+module.exports = Menu;

package/test.js

@@ -0,0 +1,13 @@
+const neurons = require('neurons.me');
+// Custom options for the neuron
+let options = {
+  name: 'x', // Custom name for the neuron
+  date: '2023-07-25', // Custom date
+  time: '12:30 PM', // Custom time
+  color: 'blue', // Custom color
+  activationFunction: x => x * 2 // Custom activation function
+};
+// Create a neuron with custom options
+let neuron = new neurons.createNeuron({ options: options });
+let layer = new neurons.Layer({ neurons: [neuron] });  
+console.log(layer.map);

package/x.js

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+const readline = require('readline');
+const neurons = require('neurons.me');
+const { logError } = require('./src/errorHandler');
+const { Menu } = require('./src/utils');
+const NeuronsHandler = require('@sui.gn/me/src/NeuronsHandler');
+const NeuralNetworksHandler = require('@sui.gn/me/src/NeuralNetworksHandler');
+const LayersHandler = require('@sui.gn/me/src/LayersHandler');
+class neuronsme_MainMenu extends Menu {
+  async display() {
+    console.log('\nWelcome to neurons.me type /q to close:');
+    console.log('1. Neurons: Create, list, update, and delete neurons');
+    console.log('2. Neural Networks: Create, list, update, and delete neural networks');
+    console.log('3. Layers: Create, list, update, and delete layers');
+    console.log('4. Show Info...');
+    this.rl.prompt();
+  }
+  async handleInput(input) {
+    switch (input) {
+      case '/q':
+        this.rl.close();
+        break;
+      case '1':
+        this.currentMenu = new neuronsme_NeuronsMenu(this.rl);
+        break;
+      case '2':
+        this.currentMenu = new neuronsme_NeuralNetworksMenu(this.rl);
+        break;
+      case '3':
+        this.currentMenu = new neuronsme_LayersMenu(this.rl);
+        break;
+      case '4':
+        console.log('Showing information of neurons.me...');
+        console.log(neurons);
+        break;
+      default:
+        console.log('Invalid option. Please choose a valid menu option.');
+    }
+    this.currentMenu.display();
+  }
+}
+class neuronsme_NeuronsMenu extends Menu {
+  async display() {
+    console.log('\nNeurons:');
+    console.log('0. Back to Home');
+    console.log('1. Create a new neuron');
+    console.log('2. List all neurons');
+    this.rl.prompt();
+  }
+  async handleInput(input) {
+    // Handle input based on the neurons menu options
+    // E.g., if input is '1', create a new neuron
+  }
+}
+class neuronsme_NeuralNetworksMenu extends Menu {
+  async display() {
+    console.log('\nNeural Networks:');
+    console.log('0. Back to Home');
+    console.log('1. Create a new neural network');
+    console.log('2. List all neural networks');
+    this.rl.prompt();
+  }
+  async handleInput(input) {
+    // Handle input based on the neural networks menu options
+    // E.g., if input is '1', create a new neural network
+  }
+}
+class neuronsme_LayersMenu extends Menu {
+  async display() {
+    console.log('\nLayers:');
+    console.log('0. Back to Home');
+    console.log('1. Create a new layer');
+    console.log('2. List all layers');
+    this.rl.prompt();
+  }
+  async handleInput(input) {
+    // Handle input based on the layers menu options
+    // E.g., if input is '1', create a new layer
+  }
+}
+class neuronsmeApp {
+  constructor() {
+    this.rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+    this.currentMenu = new neuronsme_MainMenu(this.rl);
+  }
+  start() {
+    this.rl.prompt();
+    this.rl.on('line', (input) => {
+      this.currentMenu.handleInput(input.trim());
+    }).on('close', () => {
+      console.log('Exiting .me');
+      process.exit(0);
+    });
+  }
+}
+const neurons_me_app_init = new neuronsmeApp();
+neurons_me_app_init.start();

package/y.js

@@ -0,0 +1,207 @@
+#!/usr/bin/env node
+const readline = require('readline');
+const neurons = require('neurons.me');
+const { logError } = require('./src/errorHandler');
+const { showMenu } = require('./src/utils');
+const NeuronsHandler = require('@sui.gn/me/src/NeuronsHandler');
+const NeuralNetworksHandler = require('@sui.gn/me/src/NeuralNetworksHandler');
+const LayersHandler = require('@sui.gn/me/src/LayersHandler');
+// Create the readline interface
+let rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+/*
+┳┓┏┓┳┳┳┓┏┓┳┓┏┓      
+┃┃┣ ┃┃┣┫┃┃┃┃┗┓       
+┛┗┗┛┗┛┛┗┗┛┛┗┗┛   
+neurons SECTION...*/
+let neuronsHandlerINIT = NeuronsHandler(rl);
+const promptNeuronConfig = async () => {
+  await neuronsHandlerINIT.promptNeuronConfig(rl);
+};
+const createNeuronWrapper = async () => {
+  await neuronsHandlerINIT.createNeuron(rl);
+};
+// List all neurons
+const listAllNeuronsWrapper = () => {
+  neuronsHandlerINIT.listAllNeurons();
+};
+// Update neuron properties
+const updateNeuronPropertiesWrapper = async (neuron) => {
+  await neuronsHandlerINIT.updateNeuronProperties(neuron);
+};
+// Clone neuron
+const cloneNeuronWrapper = async (neuron) => {
+  await neuronsHandlerINIT.cloneNeuron(neuron);
+};
+// Show neuron actions
+const neuronConfigWrapper = async (neuron) => {
+  await neuronsHandlerINIT.neuronConfig(rl, neuron, updateNeuronPropertiesWrapper, cloneNeuronWrapper, showMenu);
+};
+/*
+┳┓┏┓┳┳┳┓┏┓┓ ┳┓┏┓┏┳┓┓ ┏┏┓┳┓┓┏┓┏┓
+┃┃┣ ┃┃┣┫┣┫┃ ┃┃┣  ┃ ┃┃┃┃┃┣┫┃┫ ┗┓
+┛┗┗┛┗┛┛┗┛┗┗┛┛┗┗┛ ┻ ┗┻┛┗┛┛┗┛┗┛┗┛
+neuralNetworks SECTION... */
+const neuralnetworksHandlerINIT = NeuralNetworksHandler(rl);
+const createNeuralNetworkWrapper = async () => {
+  await neuralnetworksHandlerINIT.createNeuronNetwork();
+};
+const listAllNeuralNetworksWrappers = async () => {
+  await neuralnetworksHandlerINIT.listAllNeuralNetworks();
+};
+/*
+╦  ╔═╗╦ ╦╔═╗╦═╗╔═╗
+║  ╠═╣╚╦╝║╣ ╠╦╝╚═╗
+╩═╝╩ ╩ ╩ ╚═╝╩╚═╚═╝
+layers section... */
+const layersHandlerINIT = LayersHandler(rl);
+const createLayerWrapper = async () => {
+  layersHandlerINIT.createLayer();
+};
+const listAllLayersWrapper = () => {
+  layersHandlerINIT.listAllLayers();
+};
+/*
+╔╦╗╔═╗╦╔╗╔╔╦╗╔═╗╔╗╔╦ ╦
+║║║╠═╣║║║║║║║║╣ ║║║║ ║
+╩ ╩╩ ╩╩╝╚╝╩ ╩╚═╝╝╚╝╚═╝
+main menu...            */
+// MAIN MENU OPTIONS - INDEX ENTRY POINT OF .ME CLI
+let currentMenu = 'main';
+const displayMainMenu = () => {
+  console.log('\nMain Menu:');
+  console.log('1. Neurons');
+  console.log('2. Neural networks');
+  console.log('3. Layer');
+  console.log('4. Show information about available classes and methods');
+  console.log('5. Exit');
+};
+
+/*
+┌─┐┌┬┐┌─┐┬─┐┌┬┐
+└─┐ │ ├─┤├┬┘ │ 
+└─┘ ┴ ┴ ┴┴└─ ┴
+starting shell session npx .me shell ->*/
+// Starting shell session
+const startShellSession = () => {  
+  rl.setPrompt('.me> ');  // Display the initial prompt
+  rl.prompt();
+  // Handle user input
+  rl.on('line', async (input) => {
+    const command = input.trim();
+    if (command === '') {
+      // Empty input, just re-prompt the current menu
+      showMenu(rl, neuronsHandlerINIT.showNeuronMenu);
+
+      return;
+    }
+    switch (currentMenu) {
+      case 'neuron':
+      switch (command) {
+        case '1':
+          await createNeuronWrapper();
+          break;
+        case '2':
+          listAllNeuronsWrapper();
+          break;
+        case '3':
+          promptNeuronConfig();
+          break;
+        default:
+          console.log('Invalid command. Type the number of the desired option.');
+          showMenu(rl, neuronsHandlerINIT.showNeuronMenu);
+
+      }
+      break;
+      case 'neuralnetwork':
+        switch (command) {
+          case '1':
+            createNeuralNetworkWrapper();
+            break;
+          case '2':
+            listAllNeuralNetworksWrappers();
+            break;
+            case '3':
+              currentMenu = 'main';
+              showMenu(rl, neuronsHandlerINIT.showNeuronMenu);
+
+              break;
+          default:
+            console.log('Invalid command. Type the number of the desired option.');
+            showMenu(rl, neuronsHandlerINIT.showNeuronMenu);
+
+        }
+        break;
+      case 'layer':
+        switch (command) {
+          case '1':
+            createLayerWrapper();
+            break;
+          case '2':
+            listAllLayersWrapper();
+            break;
+          case '3':
+            currentMenu = 'main';
+            showMenu(rl, neuronsHandlerINIT.showNeuronMenu);
+            break;
+          default:
+            console.log('Invalid command. Type the number of the desired option.');
+            showMenu(rl, neuronsHandlerINIT.showNeuronMenu);
+        }
+        break;
+      default:
+        switch (command) {
+          case '1':
+            currentMenu = 'neuron';
+            showMenu(rl, neuronsHandlerINIT.showNeuronMenu);
+
+            break;
+          case '2':
+            currentMenu = 'neuralnetwork';
+            showMenu(rl, neuronsHandlerINIT.showNeuronMenu);
+
+            break;
+          case '3':
+            currentMenu = 'layer';
+            showMenu(rl, neuronsHandlerINIT.showNeuronMenu);
+
+            break;
+          case '4':
+            console.log('Available classes and methods:');
+            console.log(neurons);
+            showMenu(rl, neuronsHandlerINIT.showNeuronMenu);
+
+            break;
+          case '5':
+            rl.close();
+            break;
+          case 'menu':
+          case 'showmenu':
+            showMenu(rl, neuronsHandlerINIT.showNeuronMenu);
+
+            break;
+          default:
+            console.log('Invalid command. Type "exit" to quit the session or use "menu" to see options.');
+            showMenu(rl, neuronsHandlerINIT.showNeuronMenu);
+
+        }
+    }
+  }).on('close', () => {
+    console.log('Exiting .me');
+    process.exit(0);
+  });
+};
+// Define the main 'shell' command
+const mainCommand = process.argv[2];
+if (mainCommand === 'shell') {
+  // Start the interactive shell session when the 'shell' command is run
+  startShellSession();
+  // Display the main menu
+  showMenu(rl, displayMainMenu);  // Corrected line
+} else {
+  // Show usage or help message when the main command is not recognized
+  console.log('Usage: .me shell');
+  console.log('Type ".me shell" to enter the interactive shell mode.');
+}