this.me 2.9.4 → 2.9.42

package/README.md

@@ -1,20 +1,17 @@
-<img src="https://suign.github.io/assets/imgs/Cleaker-removebg-preview.png" alt="Cleak Me Please." width="244">
+<img src="https://docs.neurons.me/media/all-this/webP/this.me.webp" alt="SVG Image" width="250" height="250">
 
 # 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.
+> **This.Me** is a data-structured identity designed to generate and manage identities, attributes, properties and more.
 
-this.me is designed to generate and manage identities. It's responsible for creating a user’s identity, handling attributes, and generating hashes.
+# Getting Started:
 
-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`:**
+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';
@@ -41,21 +38,15 @@ me.be({ name: "Alice", phone: "33550000" });
 ```
 
 **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.
 
 **Example Flow:**
-
 1. **Setup**: A developer installs this.me and configures it to connect to neurons.me.
-
 2. **User Registration**: Users register their Me identity through the service, and the library connects to the neurons.me registry for verification.
-
 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.
 
 **Implementation:**
-
 ```js
 import Me from 'this.me';
 const config = {
@@ -66,67 +57,35 @@ me.register({ password: 'securePass123', email: 'alice@example.com' });
 // Verify and interact with services using the connected registry
 ```
 
-
-
 --------
 <img src="https://suign.github.io/assets/imgs/monads.png" alt="Cleak Me Please" width="244">Hello, I am **.me**
-
 ### ❯ add.me 
 ----
 
 ###### Using the CLI and this.me globally to manage user sessions.
-
 ```bash
 npm i -g this.me
 ```
+----------
 
+# What is All.This?
 
-### 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.
+###### Modular Data Structures:
 
-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.
+**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.**
 
-#### 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:
+**[this.me](https://docs.neurons.me/this.me/index.html)  - [this.audio](https://docs.neurons.me/this.audio/index.html) - [this.text](https://docs.neurons.me/this.text/index.html) - [this.wallet](https://docs.neurons.me/this.wallet/index.html) - [this.img](https://docs.neurons.me/this.img/index.html) - [this.pixel](https://docs.neurons.me/this.pixel/index.html) - [be.this](https://docs.neurons.me/be.this/index.html) - [this.DOM](https://docs.neurons.me/this.DOM/index.html) - [this.env](https://docs.neurons.me/this.env/index.html) - [this.GUI](https://docs.neurons.me/this.GUI/index.html) - [this.be](https://docs.neurons.me/this.be/index.html) - [this.video](https://docs.neurons.me/this.video/index.html) - [this.dictionaries](https://docs.neurons.me/this.dictionaries/index.html)** 
 
-```js
-// Create Me instances
-const meInstance = new Me('me');
-const youInstance = new Me('you');
-const himInstance = new Me('him');
-const herInstance = new Me('her');
-const itInstance = new Me('it');
-const usInstance = new Me('us');
-const themInstance = new Me('them');
-
-// One-hot encoding representation
-const subjects = {
-  'me': [1, 0, 0, 0, 0, 0, 0],
-  'you': [0, 1, 0, 0, 0, 0, 0],
-  'him': [0, 0, 1, 0, 0, 0, 0],
-  'her': [0, 0, 0, 1, 0, 0, 0],
-  'it': [0, 0, 0, 0, 1, 0, 0],
-  'us': [0, 0, 0, 0, 0, 1, 0],
-  'them': [0, 0, 0, 0, 0, 0, 1]
-};
-```
+#### Contribution
 
-#### 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”:
+If you are interested in collaborating or wish to share your insights, please feel free to reach out or contribute to the project.
 
-```
-[1, 0, 0, 0, 0, 0, 0] + [0, 1, 0, 0, 0, 0, 0] = [1, 1, 0, 0, 0, 0, 0]
-```
----
-### Me Deviation Formula
-**How Spread Out the data Points are around the .me?**
+#### License & Policies
 
+- **License**: MIT License (see LICENSE for details).
 
-----------
+- **Learn more** at **https://docs.neurons.me**
 
+  [Terms](https://docs.neurons.me/terms-and-conditions) | [Privacy](https://docs.neurons.me/privacy-policy)
 
+  <img src="https://docs.neurons.me/neurons.me.webp" alt="neurons.me logo" width="123" height="123">

package/index.js

@@ -8,5 +8,3 @@
 import Me from './src/me.js';
 //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/Index.md

@@ -0,0 +1,134 @@
+### **Index of `this.me` Structure**
+Here’s a comprehensive list of the components and their purposes within the `this.me` class:
+
+#### **1. Identity**
+- **Description:** Immutable attributes defining the core identity of the user.
+#### **2. Attributes**
+- **Description:** Flexible traits and descriptive properties of the user.
+#### **3. Relationships**
+- **Description:** Connections and associations with others.
+#### **4. Reactions**
+- **Description:** User’s interactions and engagements with the world.
+#### **5. Properties**
+- **Description:** Items owned or managed by the user.
+
+------
+
+### **1. The Me Structure Overview**
+#### **Core Components**
+- **Identity:** The foundation of the `this.me` object.
+  - Immutable attributes: `username`, `DID`.
+  - Core methods for validation and setup.
+
+------
+
+- **Attributes:** Fundamental identity traits.
+  Store and manage user traits dynamically:
+  - Examples: Name, age, location, pronouns, bio.
+    **Use `.be()` to add or update attributes.**
+
+    Example: 
+    ```json
+    { name: 'John Doe', age: 30, location: 'Earth' }
+    ```
+    Implement `be()` as a flexible key-value store.
+    Add validation for specific attributes (if required).
+
+------
+
+- **Relationships:** Connections with others.
+  - Examples: Friends, groups, networks, organizations.
+    **Contacts:** Individual connections.
+    **Groups:** Collections of users with shared context.
+
+    ```js
+    .relationships.addContact({ username: 'alice', status: 'friend' });
+    .relationships.createGroup({ name: 'Family', members: ['alice', 'bob'] });
+    ```
+
+  Define `addContact` and `createGroup` methods.
+  Enable nested relationship structures (e.g., groups of groups).
+
+------
+
+- **Reactions:** How a user interacts with the world.
+  Streamline all user engagements under `.react()`
+  - Examples: Likes, comments, shares, emotions.
+  - Categorization Rationale:
+    - Keeps all engagements unified.
+    - Expands easily (adding emojis, advanced reactions).
+
+  ```js
+  .react.add({ type: 'like', target: 'PostID' });
+  .react.add({ type: 'comment', target: 'PhotoID', content: 'Great pic!' });
+  ```
+  Design a structure to store and retrieve reactions efficiently.
+  Define a `log` system for reaction history.
+
+------
+
+- **Properties:** Things the user owns or manages.
+  Attach external, modular objects as user-owned assets:
+  - Use `this.me.properties` as a unified interface for ownership.
+  - Modular objects like `Wallet`, `Device`, `File`.
+  - Examples: Wallets, devices, digital files, accounts.
+  - **Sub-Methods:** Add, Share, Transfer Ownership, Revoke Access.
+
+```js
+const jabellae = new Me('jabellae'); // Create a new Me instance
+const wallet = new Wallet({ type: 'ETH', address: '0x123...' }); // Create a wallet object
+jabellae.addProperty(wallet); // Add wallet as a property to Me
+```
+
+​	Implement `add`, `share`, `transferOwnership`, and `revokeAccess` methods for properties. Define modular objects (`Wallet`, `Device`) independently.
+
+1. **Creating a Wallet**
+    The wallet is created independently and then added to the `Me` instance's properties.
+   ```javascript
+   const jabellae = new Me('jabellae'); // Create a new Me instance
+   const wallet = new Wallet({ type: 'ETH', address: '0x123...' }); // Create a wallet object
+   jabellae.addProperty(wallet); // Add wallet as a property to Me
+   ```
+
+2. **Sharing the Wallet**
+    Sharing logic is handled by the `Me` instance, not the property itself.
+   ```javascript
+   jabellae.shareProperty(wallet, 'otherMe', { permissions: 'view' });
+   ```
+
+3. **Transferring Ownership**
+    Ownership transfer is also managed by the `Me` instance.
+   ```javascript
+   jabellae.transferOwnership(wallet, 'otherMe');
+   ```
+
+------
+------
+------
+
+### **2. Why Independent Objects?**
+#### **Modularity**
+- Keeps the `this.me` instance *agnostic* of specifics.
+- Allows new property types to integrate seamlessly.
+
+#### **Reusability**
+- Each property (e.g., `this.wallet`, `this.device`) operates independently.
+- Can be ported across `this.me` instances without coupling.
+
+#### **Transferability**
+- Ownership is a property-level concern.
+- Example:
+
+  ```javascript
+  const wallet = new Wallet(owner = "me");
+  wallet.transferOwnership("otherMeInstance");
+  ```
+
+#### **Separation of Concerns**
+- Identity (`this.me`) manages relationships, attributes, and higher-level user interactions.
+- Objects like `Wallet` or `Device` manage their specific functionality.
+
+#### **Scalability**
+- Adding a new property type is as simple as:
+  1. Defining the object (e.g., `Vehicle`).
+  2. Registering it with `this.me`.

package/md/{context.md → Inmutabilidad_de_la_Identidad_basica.md}

@@ -1,7 +1,9 @@
-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:
+ El mayor acto de rebelión en un mundo que busca controlarte es ser libre de verdad.
+ 
+ **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.
+**this.me** se basa en la creación de una identidad. 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.

package/md/Questions.md

@@ -0,0 +1,62 @@
+Key Questions to Address
+Identity Core: What defines the essence of .me?
+Relationships: How does .me relate to others, groups, or larger entities?
+Belongings: What does .me own or have as personal items?
+Modularity: How do we allow external objects to seamlessly integrate with .me?
+Hierarchy of Interactions: How do we classify interactions into tiers (self, relationships, society, etc.)?
+---
+
+### **1. Identity Core: What defines the essence of `.me`?**
+   - **Essence Defined:**
+     - **Immutable Core Attributes:** `username` and `DID` (Decentralized Identifier).
+     - Clearly distinguishes the user's unique existence in the digital realm.
+   - **Practical Implementation:**
+     - Identity core is foundational and unchangeable, ensuring trust and consistency across systems.
+
+---
+
+### **2. Relationships: How does `.me` relate to others, groups, or larger entities?**
+   - **Connections Defined:**
+     - **Contacts:** Direct relationships (e.g., friends, acquaintances).
+     - **Groups:** Collections with shared contexts (e.g., family, organizations, societies).
+   - **Methods:**
+     - `.relationships.addContact()` to add individual connections.
+     - `.relationships.createGroup()` to organize groups dynamically.
+   - **Hierarchy:**
+     - Nested structures enable relationships at various tiers (e.g., groups of groups, organizations within societies).
+
+---
+
+### **3. Belongings: What does `.me` own or have as personal items?**
+   - **Properties Defined:**
+     - Everything the user owns or manages (e.g., wallets, devices, digital files).
+   - **Methods for Ownership:**
+     - `.properties.add()`, `.properties.share()`, `.properties.transferOwnership()`, `.properties.revokeAccess()`.
+   - **Modular Approach:**
+     - Allows external objects like `Wallet`, `Device`, or `Vehicle` to integrate without hardcoding.
+
+---
+
+### **4. Modularity: How do we allow external objects to seamlessly integrate with `.me`?**
+   - **Independent Objects:**
+     - Objects like `Wallet`, `Device`, etc., are designed and managed outside the `this.me` instance.
+   - **Integration:**
+     - These objects are registered to `this.me` via methods like `.addProperty()`.
+     - They maintain their internal logic while adhering to the ownership and interaction protocols defined by `.me`.
+   - **Advantages:**
+     - Scalability: Easy to introduce new objects without modifying the `this.me` core.
+     - Transferability: Ownership can move across `.me` instances seamlessly.
+
+---
+
+### **5. Hierarchy of Interactions: How do we classify interactions into tiers (self, relationships, society, etc.)?**
+   - **Tiers of Interactions:**
+     - **Reactions:** Personal engagements (`like`, `comment`, `share`).
+     - **Relationships:** Broader social connections (individuals, groups, organizations).
+     - **Attributes:** How `.me` defines itself (e.g., status, bio, pronouns).
+     - **Properties:** Interaction with owned or managed items.
+   - **Unified Structure:**
+     - Centralized under `.reactions` and `.relationships`.
+     - Interaction types remain modular and expandable, allowing for a hierarchy to emerge naturally through usage (e.g., personal to societal interactions).
+
+---

package/md/hot_encoding.md

@@ -0,0 +1,44 @@
+### 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
+// Create Me instances
+const meInstance = new Me('me');
+const youInstance = new Me('you');
+const himInstance = new Me('him');
+const herInstance = new Me('her');
+const itInstance = new Me('it');
+const usInstance = new Me('us');
+const themInstance = new Me('them');
+
+// One-hot encoding representation
+const subjects = {
+  'me': [1, 0, 0, 0, 0, 0, 0],
+  'you': [0, 1, 0, 0, 0, 0, 0],
+  'him': [0, 0, 1, 0, 0, 0, 0],
+  'her': [0, 0, 0, 1, 0, 0, 0],
+  'it': [0, 0, 0, 0, 1, 0, 0],
+  'us': [0, 0, 0, 0, 0, 1, 0],
+  'them': [0, 0, 0, 0, 0, 0, 1]
+};
+```
+
+#### 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]
+```
+---
+### Me Deviation Formula
+**How Spread Out the data Points are around the .me?**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "this.me",
-  "version": "2.9.4",
+  "version": "2.9.42",
   "description": "_me-Centric.",
   "main": "index.js",
   "scripts": {

package/src/example.js

@@ -1,6 +1,6 @@
+//this.me/src/example.js
 import Me from './me.js';
 import chalk from 'chalk';
-
 // Create a new Me instance
 let me = new Me('suign');
 // Add attributes to the identity

package/src/me.js

@@ -1,56 +1,54 @@
 //this.me/src/me.js
-import crypto from 'crypto';
-import os from 'os';
-
-// Define the .me class
-class Me{
-  // Static property to keep track of all users globally
-  static registry = {};
-
-  constructor(username = 'monad') {
+import Registry from './registry';
+class Me {
+  static registry = Registry.load();
+  constructor(username = 'default') {
     if (Me.registry[username]) {
-      throw new Error(`Username ${username} already exists in the registry.`);
+      throw new Error(`Username ${username} already exists.`);
     }
-    this.username = this.validateMe(username);
+
+    this.username = username;
     this.identity = {
-      username: this.username,
-      hash: this.sha256(),
-      host: this.getHostInfo()
+      username,
+      devices: [],
     };
-    Me.registry[username] = this; // Add to global registry
-  }
 
-  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, and it must be between 1 and 21 characters.');
-    }
+    this.addDevice(); // Automatically adds the current device
+    Me.registry[username] = this.identity;
+    Registry.save(Me.registry);
   }
 
-  sha256() {
-    return crypto.createHash('sha256').update(this.username).digest('hex');
+  static load(username) {
+    if (!Me.registry[username]) {
+      throw new Error(`Username ${username} does not exist.`);
+    }
+    return new Me(username, Me.registry[username]);
   }
 
-  getHostInfo() {
-    return {
+  addDevice(deviceInfo = null) {
+    const device = deviceInfo || {
+      deviceId: crypto.randomUUID(),
       hostname: os.hostname(),
       platform: os.platform(),
-      networkInterfaces: os.networkInterfaces()
+      isPrimary: this.identity.devices.length === 0,
     };
+
+    this.identity.devices.push(device);
+    Registry.save(Me.registry);
   }
 
-  be(attributes) {
-    for (const [key, value] of Object.entries(attributes)) {
-      this.identity[key] = value;
-    }
+  removeDevice(deviceId) {
+    this.identity.devices = this.identity.devices.filter((d) => d.deviceId !== deviceId);
+    Registry.save(Me.registry);
+  }
+
+  listDevices() {
+    return this.identity.devices;
   }
 
-  // Static method to retrieve all users
   static getAllUsers() {
-    return Me.registry;
+    return Object.keys(Me.registry);
   }
 }
 
-export default Me;
+export default Me;