this.me 2.9.1 → 2.9.4

package/README.md

@@ -1,48 +1,29 @@
-<img src="https://suign.github.io/assets/imgs/cleak_me-removebg.png" alt="DID Me Art" width="69" align="right">
-<img src="https://suign.github.io/assets/imgs/Cleaker-removebg-preview.png" alt="Cleak Me Please" width="277" align="right">
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+<img src="https://suign.github.io/assets/imgs/Cleaker-removebg-preview.png" alt="Cleak Me Please." width="244">
 
 # THIS.ME  
-
 **This.Me** is a data-structured identity.
+<img src="https://suign.github.io/assets/imgs/point.png" alt="Me" width="144"> Consider **.me** as a point.
 
-1. **Install `this.me`:**
-   Open your terminal and run the following command to install the `this.me` package:
+this.me is designed to generate and manage identities. It's responsible for creating a user’s identity, handling attributes, and generating hashes.
 
+Use Case: Suppose you're building an app where users need to create profiles or identities. You can install this.me locally in that project to manage user identities.
+
+1. ### **Install `this.me`:**
+   Open your terminal and run the following command to install the `this.me` package:
    ```js
    npm install this.me
    ```
-
-2. **Import `Me` in Your Project:**
+   
+2. ### **Import `Me` in Your Project:**
    In the JavaScript file where you want to use `this.me`, import the `Me` class.
-
    ```js
    import Me from 'this.me';
    ```
-
+   
    **Explanation**
-
-   ​	1.	**Dynamic Identity Addition**:
-
    ​	•	The **be** method in the **Me** class accepts an object of **key-value pairs** and **adds these to the identity object**.
-
-   ​	2.	**Flexible Attribute Addition**:
-
    ​	•	You can call **me.be()** multiple times with different attributes to dynamically update the identity object.
-
+   
    ```javascript
    // Create a new Me instance
    let me = new Me("xyxyxy");
@@ -56,43 +37,60 @@
 
 ```js
 // Add attributes to the identity
-me.be({ name: "XXXY WWC", phone: "33550000" });
+me.be({ name: "Alice", phone: "33550000" });
 ```
 
-​		**Dynamic Property Assignment**:
+**1. Registry as a Service:**
+
+• The registry becomes a centralized service hosted by an authority (e.g., neurons.me).
+
+• This service would handle the verification and management of all Me instances across the network.
 
-​	•	We use an object users to store Me instances, with each key being the username.
+**Example Flow:**
 
-​	•	`users[username] = new Me(username)` dynamically assigns the Me instance to a key that matches the username.
+1. **Setup**: A developer installs this.me and configures it to connect to neurons.me.
 
-​		**Accessing Instances**:
+2. **User Registration**: Users register their Me identity through the service, and the library connects to the neurons.me registry for verification.
 
-​	•	You can access the Me instance using the username as the key: `users['suign']`.
+3. **Service Interaction**: When a user interacts with a service that uses this.me, the service can trust the identity by querying the selected registry.
 
-​		**Adding Attributes**:
+**Implementation:**
 
-​	•	The **be()** method is used to add attributes to the identity object.
+```js
+import Me from 'this.me';
+const config = {
+  registryURL: 'https://registry.neurons.me', // Registry authority URL
+};
+let me = new Me('alice', config);
+me.register({ password: 'securePass123', email: 'alice@example.com' });
+// Verify and interact with services using the connected registry
+```
 
-.	**Example Usage**:
 
-​	•	Two users, user1 and user2, are created and their identities are dynamically managed within the **users** object.
 
 --------
+<img src="https://suign.github.io/assets/imgs/monads.png" alt="Cleak Me Please" width="244">Hello, I am **.me**
 
-### Neural Networks - **One-Hot Encoding**
+### ❯ add.me 
+----
 
-------
+###### Using the CLI and this.me globally to manage user sessions.
 
+```bash
+npm i -g this.me
+```
+
+
+### Neural Networks - **One-Hot Encoding**
+--------
 To represent the combinations of **“me, you, him, her, it, us, them”** in a neural network, we need to convert the elements into a suitable format for neural network processing, such as one-hot encoding, and design a neural network architecture that can process these inputs.
 
 Here’s a step-by-step approach to achieve this:
-
 1.	**One-Hot Encoding:** Convert each element (“me”, “you”, “him”, “her”, “it”, “us”, “them”) into a one-hot encoded vector.
 2.	**Combination Representation:** Create input vectors for each combination by combining the one-hot encoded vectors.
 3.	**Neural Network Design:** Design a simple neural network to process these input vectors.
 
 #### Step 1: One-Hot Encoding
-
 One-hot encoding represents each element as a binary vector with a single high (1) value and the rest low (0). For the elements “me”, “you”, “him”, “her”, “it”, “us”, “them”, we can assign the following one-hot encoded vectors:
 
 ```js
@@ -118,73 +116,17 @@ const subjects = {
 ```
 
 #### Step 2: Combination Representation
-
 For each combination, we can create an input vector by combining the one-hot encoded vectors of its elements. For example:
-
 Combination “me, you” would be represented as the sum of the one-hot vectors for “me” and “you”:
 
 ```
 [1, 0, 0, 0, 0, 0, 0] + [0, 1, 0, 0, 0, 0, 0] = [1, 1, 0, 0, 0, 0, 0]
 ```
-
----
-Hello, I am .me
-? Who are you? (Use arrow keys)
-❯ add.me 
 ---
+### Me Deviation Formula
+**How Spread Out the data Points are around the .me?**
 
-1. **Install `this.me`:**
-   Open your terminal and run the following command to install the `this.me` package:
-   
-   ```js
-   npm install this.me
-   ```
-   
-2. **Import `Me` in Your Project:**
-   In the JavaScript file where you want to use `this.me`, import the `Me` class.
-   
-   ```js
-   import Me from 'this.me';
-   ```
-   
-3. **Create an Instance of `Me`:**
-   Instantiate the `Me` class with the required user details.
-   
-   ```js
-   const user = new Me('John', 'Doe', '1990-01-01', 'password123', '1234');
-   ```
-   
-4. **Validate and Use the Instance:**
-   Utilize the instance for user data validation and preparation for cryptographic actions.
-   In other words. Log In.
-   ```js
-   try {
-       const identity = user.getMe();
-       // Ready for hashing and cryptographic signatures
-   } catch (error) {
-       console.error(error.message);
-       // Error handling for missing fields
-   }
-   ```
-
-This quick start guide provides a straightforward path to incorporating `this.me` into your project, enabling you to manage user identities and prepare them for secure cryptographic processes efficiently.
 
 ----------
 
-# About All.This
-## Modular Data Structures:
-**[this.me](https://suign.github.io/this.me)  - [this.audio](https://suign.github.io/this.audio) - [this.text](https://suign.github.io/this.text) - [this.wallet](https://suign.github.io/this.wallet) - [this.img](https://suign.github.io/this.img) - [this.pixel](https://suign.github.io/Pixels) - [be.this](https://suign.github.io/be.this) - [this.DOM](https://suign.github.io/this.DOM) - [this.env](https://suign.github.io/this.env/) - [this.GUI](https://suign.github.io/this.GUI) - [this.be](https://suign.github.io/this.be) - [this.video](https://suign.github.io/this.video) - [this.atom](https://suign.github.io/this.atom) - [this.dictionaries](https://suign.github.io/this.dictionaries/)**
-
-**Each module** in **[all.this](https://neurons.me/all-this)** represents a specific **datastructure**. These classes encapsulate the functionalities and **data specific to their domain.**
-
-## Neurons.me
-### License & Policies
-- **License**: MIT License (see LICENSE for details).
-- **Privacy Policy**: Respects user privacy; no collection/storage of personal data.
-- **Terms of Usage**: Use responsibly. No guarantees/warranties provided. [Terms](https://www.neurons.me/terms-of-use) | [Privacy](https://www.neurons.me/privacy-policy)
-  [By neurons.me](https://neurons.me)
-
-  <img src="https://suign.github.io/neurons.me/neurons_logo.png" alt="neurons.me logo" width="123" height="123" style="width123px; height:123px;">
-
-
 

package/index.js

@@ -2,24 +2,11 @@
 /**
  * @module This.Me
  * @description
- * This.Me adapts to various environments, enabling `.me` objects to function both locally and within a network. 
- *  A `.me` object authenticated on a network accesses data beyond the local scope, 
- *  while unauthenticated instances are confined to local data.
- *  This dual functionality ensures seamless interoperability and heightened security.
- *  Command Definitions and Interactive Shell.*/
+ *  This.Me is a data-structured identity...    
+ * */
 
-//index.js in the `this.me` package
 import Me from './src/me.js';
-
-//when a user declares "I am," their digital existence is affirmed and recorded in the system.
-//The user's `.me` object is then retrieved and displayed.
-//The user is greeted with their `.me` object, and the system is queried about its own identity.
-/*
-User Instance Hash: Anchoring each user’s identity and space is a cryptographic hash, providing a secure and unique foundation.
-This unique space not only encapsulates its creator but can also forge Inter-Space Connections with others, manifesting in:
-Relative Paths: Tailoring interactions within a user’s space, relative paths connect varied datasets, objects, and interactions in a user-oriented manner.
-Cross Paths: Creating conduits between user spaces, allowing permissioned access to specific datasets and interactions.
-Dual Endpoints: Curating diverse experiences through endpoints that exhibit varied interactions or representations based on user permissions and contexts.
-*/
-
+//when a user declares "I am %.me," their digital existence is affirmed and recorded in the system.
 export default Me;
+
+console.log("this.me is loaded!!");

package/md/context.md

@@ -0,0 +1,42 @@
+Lo que estás describiendo sobre **this.me** y el proceso de autenticación con **Cleaker** como una red de identificación descentralizada (**DID**) tiene sentido dentro de un marco de criptografía y autenticación distribuida. A continuación, desgloso los puntos importantes para asegurarnos de que el concepto sea claro y funcional:
+
+### **Inmutabilidad de la Identidad Básica**
+Tu sistema **this.me** se basa en la creación de una identidad criptográficamente segura. Los componentes inmutables que mencionas (nombre de usuario, email y la red de autenticación) son fundamentales para que el sistema garantice que la identidad siempre se pueda verificar a partir de un hash único.
+
+1. **Nombre de Usuario (username)**: El nombre de usuario es clave en la identidad. No puede cambiar una vez creado porque el hash que lo representa depende de esta cadena de caracteres.
+2. **Correo Electrónico (email)**: Esto actúa como otra pieza inmutable, probablemente porque es un dato importante para autenticar usuarios a través de redes o servicios.
+3. **Red de Autenticación (Cleaker)**: Como mencionas, **Cleaker** actuaría como el **DID**, o sea, la autoridad central que autentica tu identidad. Es clave para asegurar que no cualquiera pueda crear una identidad falsa.
+
+### **Proceso de Creación del Hash**
+Lo que estás describiendo es un esquema de hashing similar al que se usa en la criptografía para asegurar que los datos no sean manipulados. Cuando generas una identidad con `this.me`, combinas información inmutable (username, email, red) para generar un **hash único**, que se convierte en tu **clave pública**.
+
+1. **Hash como Clave Pública**: Cuando hasheas tu información (e.g., nombre + email + red), se genera una clave pública (hash). Esta clave es única para cada combinación de información.
+   - Si cambias incluso una letra de tu nombre o red, el hash resultante será completamente diferente.
+   - Este hash será tu "firma digital" o clave pública para verificarte ante otros sistemas.
+
+2. **Encriptación y Desencriptación de Datos**: Utilizando tu **clave pública** (hash generado), puedes firmar o desencriptar información que hayas dejado en el sistema. Esencialmente, es una forma de probar que eres el propietario legítimo de esa clave.
+   - Si alguien intenta usar un hash distinto (porque cambió alguna información), no podrá desencriptar la información asociada a tu clave pública original.
+
+### **Uso de Cleaker como DID**
+**Cleaker** sería la red de confianza que actúa como verificador. En este caso:
+- **Cleaker** puede autenticar tu identidad, asegurando que el hash generado sea correcto, en el sentido de que el nombre de usuario, email, y red de autenticación son válidos.
+- **Cleaker** también sirve como autoridad para evitar que cualquiera pueda generar una identidad falsa o duplicada. Si intentas acceder a la red con información diferente, el sistema rechaza la autenticación porque el hash no coincide con los registros en la red.
+
+### **Flujo Ejemplificado de Autenticación**
+1. Creas tu identidad en **this.me** con tu nombre de usuario, email y red de autenticación (**Cleaker**).
+2. **this.me** genera un **hash único** para esa combinación de datos, lo que te da una **clave pública**.
+3. Puedes usar esa clave pública para autenticarte en cualquier servicio compatible, y solo tú puedes desencriptar los datos usando tu hash, ya que corresponde exactamente con la información que usaste para crearlo.
+4. Si cambias cualquier parte de tu información (nombre, email o red), obtendrás un hash completamente diferente, lo que efectivamente cambia tu identidad digital.
+
+### **Encriptación y Desencriptación**
+Al tener tu clave pública, puedes usarla para desencriptar datos que hayas almacenado en sistemas que utilizan **this.me**. La clave pública se usa para verificar tu identidad y acceder a la información que has dejado. Como mencionabas:
+
+- Si hasheas "jose" y "abella", obtendrás un hash específico.
+- Si cambias "abella" por "abellae", el hash cambia y no podrás desencriptar la información almacenada bajo el hash anterior.
+
+Este proceso asegura que tu identidad es única y está protegida criptográficamente.
+
+### **Conclusión**
+Este sistema de identidad descentralizada que estás describiendo se asemeja a los **DIDs** utilizados en blockchain y criptografía, donde las identidades no dependen de un servidor centralizado, sino de la prueba criptográfica de su validez. **Cleaker** actuaría como una red que verifica la validez del hash, y **this.me** genera y gestiona las identidades de una forma flexible pero segura. El uso de hashes y criptografía garantiza que las identidades sean inmutables y verificables sin depender de terceros centralizados.
+
+Este sistema tiene aplicaciones en una amplia gama de servicios donde la autenticación segura es fundamental y donde se quiere evitar la creación de múltiples credenciales en diferentes plataformas.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "this.me",
-  "version": "2.9.1",
+  "version": "2.9.4",
   "description": "_me-Centric.",
   "main": "index.js",
   "scripts": {
@@ -16,7 +16,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/suiGn/this.me.git"
+    "url": "git+https://github.com/neurons-me/this.me.git"
   },
   "homepage": "https://www.npmjs.com/package/this.me",
   "docs": "https://suiGn.github.io/this.me",
@@ -27,6 +27,7 @@
   "category": "dataformatter",
   "dependencies": {
     "chalk": "^5.3.0",
+    "commander": "^12.1.0",
     "inquirer": "^9.2.16"
   }
 }

package/src/example.js

@@ -6,11 +6,11 @@ let me = new Me('suign');
 // Add attributes to the identity
 me.be({ fullName: "Jose", lastName: "Abella" });
 me.be({ xy: "z" });
-console.log(me.identify());
+console.log(me);
 // Examplconsole.log(me.identity());e with another instance
 let anotherMe = new Me('anotherUser');
 anotherMe.be({ nickname: "hero", favoriteColor: "blue" });
-console.log(anotherMe.identify());
+console.log(anotherMe);
 // Create a new Me instance with dynamic property name
 let user = 'suign';
 let users = {};
@@ -20,4 +20,6 @@ users[user].be({ fullName: "ZZZ", lastName: "WWW" });
 users[user].be({ xy: "axax" });
 console.log(users[user]);
 
+console.log(users);
+
 

package/src/me.js

@@ -3,32 +3,36 @@ import crypto from 'crypto';
 import os from 'os';
 
 // Define the .me class
-class Me {
+class Me{
+  // Static property to keep track of all users globally
+  static registry = {};
+
   constructor(username = 'monad') {
-    this.username = this.validateUsername(username);
+    if (Me.registry[username]) {
+      throw new Error(`Username ${username} already exists in the registry.`);
+    }
+    this.username = this.validateMe(username);
     this.identity = {
       username: this.username,
       hash: this.sha256(),
       host: this.getHostInfo()
     };
+    Me.registry[username] = this; // Add to global registry
   }
 
-  // Method to validate the username
-  validateUsername(username) {
-    const regex = /^[a-zA-Z0-9]+$/; // Only letters and numbers
+  validateMe(username) {
+    const regex = /^[a-zA-Z0-9]{1,21}$/;
     if (regex.test(username)) {
       return username;
     } else {
-      throw new Error('Incorrect username. Only letters and numbers are allowed.');
+      throw new Error('Incorrect username. Only letters and numbers are allowed, and it must be between 1 and 21 characters.');
     }
   }
 
-  // Method to generate a cryptographic hash of the username
   sha256() {
     return crypto.createHash('sha256').update(this.username).digest('hex');
   }
 
-  // Method to get host information
   getHostInfo() {
     return {
       hostname: os.hostname(),
@@ -37,16 +41,15 @@ class Me {
     };
   }
 
-  // Method to add key-value pairs to the identity object
   be(attributes) {
     for (const [key, value] of Object.entries(attributes)) {
       this.identity[key] = value;
     }
   }
 
-  // Method to get the identity object
-  identify() {
-    return this.be;
+  // Static method to retrieve all users
+  static getAllUsers() {
+    return Me.registry;
   }
 }