this.me 2.1.5 → 2.1.8

package/README.md

@@ -1,99 +1,43 @@
-# **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.
+# .me Suite - Your AI Playground
 
-### Installation
+### Introduction
 
-#### Option 1 Global
+Welcome to the .me suite, a comprehensive and interactive command-line interface designed to supercharge your AI projects. Whether you're working on neural networks, experimenting with deep learning models, or exploring other cutting-edge technologies, .me suite provides you with the tools and modules you need.
 
-To empower yourself with the **me CLI**, simply install it globally using npm. Open your terminal and enter the following command:
+### Key Features
 
-```
-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
+neurons.me: A specialized module for managing neural networks. Create, update, and delete neurons, layers, and complex neural network architectures effortlessly.
+**cleaker:** An extension for working with the Cleaker application.
+**Modular Design:** Easily extend the suite with additional modules, each with its own CLI functionality.
+**Interactive Shell:** Navigate through various options and functionalities using a user-friendly command-line interface.
+Installation
 
-# 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
+npm install @sui.gn/me
 ```
 
-# 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.
+### Usage
 
-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.
+After installation, you can launch the .me suite by running:
 
-### Create a new neuron:
 ```
-npx .me createNeuron
+npx .me
 ```
 
-```
-npx .me new NeuralNetwork();
-```
+Follow the on-screen prompts to navigate through the available modules and options.
 
-### 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.
+### Future Projections
+
+The *.me suite i*s continuously evolving with plans for even more exciting features:
 
-# 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).
+**Additional Modules:** We'll be adding more modules to cater to various AI domains, such as natural language processing, computer vision, and more.
+**Enhanced Usability:** Ongoing improvements to the user interface will make navigation and task execution even more intuitive.
+**Community Contributions:** Open for community-driven enhancements, allowing developers to contribute modules and features to broaden the suite's capabilities.
+Contribute
+Contributions are welcome! Feel free to open an issue or submit a pull request on the GitHub repository.
 
-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).
+### License
 
-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.
+This project is licensed under the MIT License. See the LICENSE file for details.
 
-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.
+This README provides an overview of the project, instructions for installation and usage, and highlights future projections. Feel free to modify or expand it as needed. Congratulations on building this exciting tool, and good luck with its continued development!

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "this.me",
-  "version": "2.1.5",
+  "version": "2.1.8",
   "description": "CLI for managing the .me suite.",
   "bin": {
     ".me": "./index.js"