this.me 2.9.43 → 2.9.51

package/README.md

@@ -1,77 +1,214 @@
 <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 designed to generate and manage identities, attributes, properties and more.
+> **This.Me** is a data-structured identity designed to generate and manage identities, attributes, properties and more. It combines privacy, user control, and secure interoperability.
 
-# Getting Started:
+<strong>.me</strong> is your identity that lives on your machine, under your control. It holds attributes, relationships, and keys that define who you are—and crucially, <strong>how you relate to others</strong>.
+
+ Each <strong>.me</strong> instance can pair with other authorities or identities using its <strong>cryptographic keys</strong>, establishing <strong>trust through signatures and endorsements</strong>. 
+
+Instead of logging in through third-party services, you can validate your identity or vouch for someone else’s using these key exchanges. This enables a decentralized trust model where relationships are verifiable, persistent, and portable.
 
+# Getting Started:
 1. ##### **Install `this.me`:**
    Open your terminal and run the following command to install the `this.me` package:
    ```js
-   npm install this.me
+   npm i -g 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';
-   ```
-   
-   **Explanation**
-   ​	•	The **be** method in the **Me** class accepts an object of **key-value pairs** and **adds these to the identity object**.
-   ​	•	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");
-   
-   // Add attributes to the identity
-   me.be({ a: "XXX", b: "YYY" });
-   me.be({ c: "z" });
+
+2. **Run this command on your terminal:**
+
+   ```bash
+   me
    ```
 
-**A less abstract example:**
+The **Me** class represents a **persistent identity**, stored as an encrypted file (username.me) in ~/.this/me. This file contains:
+- An identifier (username)
+- Keys (private/public — currently placeholders)
+- User-defined attributes
+- Relationships and other social elements (reactions, attributies, properties, endorsements...)
+
+It can be **created**, **read** (if you have the correct hash), **modified in memory**, and then **saved again** in encrypted form.
+
+# Command Line Options:
+
+**Run this commands on your terminal:**
+
+```bash
+me create
+```
+
+- **Description**: Creates a new .me identity.
+- **Flow**: Prompts for username and hash (secret key), then saves an encrypted file at ~/.this/me/username.me.
+
+------
+
+```bash
+me show [username]
+```
+
+- **Description**: Shows the decrypted contents of an identity.
+- **Flow**:
+  - If [username] is not provided, it prompts for it.
+  - Always prompts for the hash to unlock the identity.
+  - If successful, prints the identity as JSON.
+
+------
+
+```bash
+me list
+```
+
+- **Description**: Lists all local .me identities.
+- **Flow**: Reads the ~/.this/me directory and prints all .me files (usernames).
+
+------
+
+# How this.me **Works (Simplified)**
+
+The Me class creates and manages a **local, encrypted identity file** based on a username and a secret hash.
+
+#### **Creating a new identity**
+
+When you run:
 
 ```js
-// Add attributes to the identity
-me.be({ name: "Alice", phone: "33550000" });
+Me.create('abellae', 'mySecretHash');
 ```
 
-**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.
+It does the following:
+
+- Builds a .me file path: ~/.this/me/abellae.me.
+- Creates some **identity data** (username, keys, attributes, etc.).
+- Uses the hash to **encrypt** that data with AES-256-CBC:
+  - It generates a random iv (initialization vector).
+  - Derives a key from the hash (sha256(hash)).
+  - Stores the encrypted result as iv + encryptedData.
+
+> 🔒 The hash is **never saved** — it’s just used as a secret key.
 
-**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.
+------
+
+#### Loading an existing identity
+
+When you run:
 
-**Implementation:**
 ```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
+Me.load('abellae', 'mySecretHash');
 ```
 
---------
+It:
+
+- Reads the encrypted .me file.
+- Extracts the first 16 bytes as iv.
+- Recomputes the key from the given hash.
+- Tries to decrypt the file.
+- If it works, it unlocks the identity and loads the data into memory.
+
+------
+
+#### **Using the unlocked identity**
+
+Once unlocked, you can:
+
+- Set attributes: me.be('developer', true)
+- Add endorsements: me.addEndorsement(...)
+- View attributes: me.getAttributes()
+- Save updates with: me.save('mySecretHash')
+
+------
+
+#### Locking the identity
+
+You can clear the identity from memory with:
+
+```js
+me.lock();
+```
+
+This keeps the encrypted file on disk but removes all data from RAM.
+
+------
+
+### **Summary**
+
+- Your identity is encrypted on your own machine.
+- Only the correct hash can unlock it.
+- No third parties are involved.
+- The .me file is secure, portable, and self-owned.
+
+Let me know if you’d like a diagram or visual flow to go with this explanation!
+
+---
+
+### 🔍 Core Principles
+
+1. **Freedom to Declare**
+   Anyone can generate a `.me` identity locally without external approval.
+2. **Trusted Endorsements**
+   Authorities (e.g., Cleaker) can endorse `.me` identities without controlling them.
+3. **Local Ownership**
+   All sensitive data (including private keys) stays on the user's machine.
+
+---
+### 📁 File Structure
+* `~/.this/me/username.me.json` — Encrypted identity file
+* `.me` includes:
+
+  * `username`
+  * `publicKey`, `privateKey` (encrypted)
+  * `attributes`, `relationships`, `reactions`, `properties`, `relationships`
+  * `endorsements`
+
+---
+### 🔐 Cryptographic Model
+* Identity is unlocked using a user-defined `hash` (password).
+* This hash decrypts the local `.me` file.
+* The identity includes:
+
+  * A **key pair** (public/private) for signing and verification.
+  * Optional **endorsements** signed by Cleaker or other authorities.
+
+---
+### 🛡️ Security Model
+* No private key ever leaves the local `.me` file.
+* Endorsements are public and verifiable using the public key.
+* If compromised, user can rotate keys and notify authorities.
+
+---
+## 🌐 Multi-Device Support
+* `.me` can be restored using a seed phrase or backup.
+* New devices can be authorized using signatures from old devices.
+
+---
+## ⚖️ Responsibilities
+* **this.me**
+  * Local file management, encryption, signing.
+  * CLI + API for usage.
+
+* **Cleaker / Authorities**
+
+  * Store trusted records of `username` + `publicKey`
+  * Provide validation/endorsement services.
+
+---
+## 🌍 Use Cases
+* Digital signature of documents
+* Smart contract interaction
+* Federated profiles with trust anchors
+* Group identity and shared contexts (`me && you && them in context/friends`)
+
+---
+By default, **this.me** uses the **local file system (~/.this/me/)** to store and manage identity data.
+No external service is required.
+
 <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?
-
 ###### Modular Data Structures:
-
 **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.**
 
 **[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)** 
@@ -81,7 +218,7 @@ If you are interested in collaborating or wish to share your insights, please fe
 
 #### License & Policies
 - **License**: MIT License.
-- **Learn more** at **https://docs.neurons.me**
-  [Terms](https://docs.neurons.me/terms-and-conditions) | [Privacy](https://docs.neurons.me/privacy-policy)
+- **Learn more** at **https://neurons.me**
+  [Terms](https://neurons.me/terms-and-conditions) | [Privacy](https://neurons.me/privacy-policy)
 
   <img src="https://docs.neurons.me/neurons.me.webp" alt="neurons.me logo" width="123" height="123">

package/bin/me.cli.js

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+// ./bin/me.cli.js
+import { Command } from 'commander';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { existsSync } from 'fs';
+import path from 'path';
+import os from 'os';
+import Me from '../src/me.js';
+import { validateSetup } from '../src/scripts/setup_validation.js';
+validateSetup(); // Asegura que ~/.this y ~/.this/me existen antes de usar el CLI
+const program = new Command();
+const ME_DIR = path.join(os.homedir(), '.this', 'me');
+// Utilidad para obtener ruta de archivo `.me`
+const getMeFilePath = (username) => path.join(ME_DIR, `${username}.me`);
+program
+  .name('me')
+  .description('CLI to manage this.me identities')
+  .version('1.0.0');
+// Comando: crear una identidad .me
+program
+  .command('create')
+  .description('Create new .me identity')
+  .action(async () => {
+    const { username, hash } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'username',
+        message: 'Enter a username:',
+      },
+      {
+        type: 'password',
+        name: 'hash',
+        message: 'Define your hash (secret key):',
+        mask: '*',
+      }
+    ]);
+    const mePath = getMeFilePath(username);
+    if (existsSync(mePath)) {
+      console.log(chalk.red(`❌ Identity '${username}' already exists.`));
+      return;
+    }
+    const me = await Me.create(username, hash);
+    console.log(chalk.green(`✅ Identity '${me.username}' created and saved as ${mePath}`));
+  });
+
+// Command: show identity contents
+program
+  .command('show')
+  .description('Show contents of a .me identity')
+  .argument('[username]', 'Username of the identity to show')
+  .action(async (usernameArg) => {
+    const { username, hash } = await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'username',
+        message: 'Enter username to view:',
+        when: () => !usernameArg,
+      },
+      {
+        type: 'password',
+        name: 'hash',
+        message: 'Enter your hash to unlock:',
+        mask: '*',
+      }
+    ]);
+
+    const finalUsername = usernameArg || username;
+
+    try {
+      const me = await Me.load(finalUsername, hash);
+      console.log(chalk.cyan(`\n📂 Identity '${finalUsername}':\n`));
+      console.log(JSON.stringify(me, null, 2));
+    } catch (err) {
+      console.log(chalk.red(`Error: ${err.message}`));
+    }
+  });
+
+// Comando: listar identidades locales
+program
+  .command('list')
+  .description('List available local .me identities')
+  .action(async () => {
+    const fs = await import('fs/promises');
+    fs.readdir(ME_DIR)
+      .then(files => {
+        const meFiles = files.filter(file => file.endsWith('.me'));
+        if (meFiles.length === 0) {
+          console.log(chalk.yellow('⚠️  No registered identities found.'));
+        } else {
+          console.log(chalk.cyan('📇 Available identities:'));
+          meFiles.forEach(file => console.log('•', file.replace('.me', '')));
+          console.log(chalk.gray('\nTip: Use `me show` or `me show <username>` to view identity contents.'));
+        }
+      })
+      .catch(err => console.log(chalk.red(`Error: ${err.message}`)));
+  });
+
+program.parse(process.argv);

package/index.js

@@ -1,10 +1,12 @@
-//index.js
+// index.js
 /**
  * @module This.Me
  * @description
  *  This.Me is a data-structured identity...    
- * */
+ */
 
+import { validateSetup } from './src/scripts/setup_validation.js';
+validateSetup(); // Asegura que ~/.this y ~/.this/me existen antes de continuar
 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;
+// when a user declares "I am %.me," their digital existence is affirmed and recorded in the system.
+export default Me;

package/notes/Entonces_Que_es_me.md

@@ -0,0 +1,9 @@
+👤 Entonces, ¿qué es .me?
+
+.me es el sujeto.
+Es quien dice “yo”.
+Es la llave privada, la biografía, la voluntad.
+
+.me es local, silencioso, estático.
+No “vive”, no escucha.
+Solo es consultado y afirma.

package/notes/Index of this.me Structure.md

@@ -0,0 +1,154 @@
+### **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.
+  - Incluye claves criptográficas necesarias para autenticación, firma y encriptación.
+#### **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`, `publicKey`, `privateKey`.
+  - Core methods for validation, key generation, and secure signing.
+
+  - Example key storage:
+    ```json
+    {
+      "username": "jabellae",
+      "DID": "did:cleaker:xyz123",
+      "publicKey": "abc123...",
+      "privateKey": "<encrypted or local-only>"
+    }
+    ```
+
+  - Example method:
+    ```js
+    jabellae.sign("message to sign"); // Returns signature using stored private key
+    ```
+
+  ---
+
+- **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/notes/Summary.md

@@ -0,0 +1,125 @@
+# this.me — Identity System
+
+## ✨ Summary
+`this.me` is a decentralized identity system designed to allow users to manage their own identities locally, with optional validation by external authorities such as Cleaker. It combines privacy, user control, and secure interoperability.
+
+
+## 🔐 Identity Model Comparison
+| **Model**            | **Where your identity lives** | **Local signing** | **Real freedom**        |
+|----------------------|-------------------------------|-------------------|--------------------------|
+| Web2 (Facebook, etc) | On their servers              | ❌                | ❌                       |
+| Web3 (wallets)       | In extensions or apps         | ✅                | 🟡 (fragmented)          |
+| `this.me`            | In your OS `.this/me/`        | ✅✅              | ✅✅✅                   |
+
+---
+
+## 🔍 Core Principles
+1. **Freedom to Declare**
+   Anyone can generate a `.me` identity locally without external approval.
+2. **Trusted Endorsements**
+   Authorities (e.g., Cleaker) can endorse `.me` identities without controlling them.
+3. **Local Ownership**
+   All sensitive data (including private keys) stays on the user's machine.
+
+---
+## 📁 File Structure
+* `~/.this/me/username.me.json` — Encrypted identity file
+* `.me` includes:
+
+  * `username`
+  * `publicKey`, `privateKey` (encrypted)
+  * `attributes`, `relationships`, `reactions`, `properties`, `relationships`
+  * `endorsements`
+
+---
+
+## 🔎 Identity Lifecycle
+
+### 1. Create Identity
+```bash
+me create jabellae
+# Prompts for hash (e.g. 4242)
+# Generates encrypted .me file
+```
+
+### 2. Register/Endorse with Authority
+```bash
+me endorse --with cleaker
+# Signs and shares publicKey with Cleaker
+```
+
+### 3. Verify Identity
+```bash
+me verify --with cleaker
+# Validates signature and authority endorsement
+```
+
+### 4. Migrate Across Devices
+```bash
+me restore --from-seed
+# Or use encrypted backup file + hash
+```
+
+### 5. Rotate Keys
+```bash
+me rotate
+# Generates new key pair, requires re-endorsement
+```
+
+---
+
+## 🔐 Cryptographic Model
+* Identity is unlocked using a user-defined `hash` (password).
+* This hash decrypts the local `.me` file.
+* The identity includes:
+
+  * A **key pair** (public/private) for signing and verification.
+  * Optional **endorsements** signed by Cleaker or other authorities.
+
+---
+
+## 🛡️ Security Model
+* No private key ever leaves the local `.me` file.
+* Endorsements are public and verifiable using the public key.
+* If compromised, user can rotate keys and notify authorities.
+
+---
+
+## 🌐 Multi-Device Support
+* `.me` can be restored using a seed phrase or backup.
+* New devices can be authorized using signatures from old devices.
+
+---
+
+## ⚖️ Responsibilities
+
+* **this.me**
+  * Local file management, encryption, signing.
+  * CLI + API for usage.
+
+* **Cleaker / Authorities**
+
+  * Store trusted records of `username` + `publicKey`
+  * Provide validation/endorsement services.
+
+---
+
+## 🌍 Future Use Cases
+* Digital signature of documents
+* Smart contract interaction
+* Federated profiles with trust anchors
+* Group identity and shared contexts (`me && you && them in context/friends`)
+
+---
+
+## 📖 Glossary
+* `hash`: A password-like string used to unlock `.me`
+* `endorsement`: Signature from a recognized authority on the identity
+* `publicKey/privateKey`: Cryptographic key pair for identity signing
+* `Cleaker`: Example identity authority ledger
+
+---
+
+**Author:** suiGn / neurons.me
+**License:** MIT
+**Project:** [this.me](https://www.npmjs.com/package/this.me)

package/notes/The Problem: Decentralized Yet Trustworthy.md

@@ -0,0 +1,13 @@
+The Problem: Decentralized Yet Trustworthy
+Identity, by its nature, is both personal and relational. On the one hand, we want the freedom to define ourselves without external constraints. On the other, our identities must often be validated by trusted authorities to engage in meaningful transactions, whether signing a digital contract or interacting with a service.
+
+Traditional centralized systems — such as social media platforms, government IDs, or corporate logins — often prioritize control over freedom. These systems require users to surrender their data and identities to be recognized. While decentralized technologies like blockchains have emerged to challenge this model, they introduce their own complexities and limitations, such as over-reliance on cryptographic keys or lack of intuitive identity frameworks.
+
+The question arises:How can we create an identity system that respects personal sovereignty while ensuring trust and usability in a networked world?
+
+Enter This.me: A New Paradigm for Identity
+This.me offers a framework for identity creation and interaction that revolves around two core principles:
+
+1. Freedom to Declare: Anyone can create a `.me` instance and define their identity without external permissions. This identity exists as a standalone object, enabling users to interact in a purely self-declared state.
+
+2. Trust Anchors: When needed, central authorities or networks, such as Cleaker, can validate the identity. These authorities provide the infrastructure for authentication, signing, and verification without compromising the user’s control over their identity.

package/notes/Understanding me && you && himContext.md

@@ -0,0 +1,11 @@
+This structure implies:
+
+1. Logical Grouping of Entities: me && you && him represents a logical grouping, where each entity is included as part of a broader relationship.
+
+2. Contextual Scoping: Context/mexicans provides a scope within which this relationship exists, giving meaning to the relationship without establishing a strict hierarchy among me, you, and him.
+
+3. Dynamic Meaning: The meaning can change based on context. For example:
+
+• me && you && himContext/mexicans could mean a group of entities (me, you, him) sharing a “Mexican” attribute.
+
+Context/friends might represent the same group within a “friends” context, applying different attributes or significance.

package/package.json

@@ -1,14 +1,15 @@
 {
   "name": "this.me",
-  "version": "2.9.43",
+  "version": "2.9.51",
   "description": "_me-Centric.",
   "main": "index.js",
   "scripts": {
     "start": "node index.js",
-    "test": "test"
+    "test": "test",
+    "postinstall": "node src/scripts/setup.js"
   },
   "bin": {
-    ".me": "src/.me.cli.js"
+    "me": "bin/me.cli.js"
   },
   "keywords": [
     "this.me",

package/src/me.js

@@ -1,53 +1,147 @@
-//this.me/src/me.js
-import Registry from './registry';
-class Me {
-  static registry = Registry.load();
-  constructor(username = 'default') {
-    if (Me.registry[username]) {
-      throw new Error(`Username ${username} already exists.`);
-    }
+// src/me.js
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+import os from 'os';
+
+const ROOT_DIR = path.join(os.homedir(), '.this', 'me');
 
+class Me {
+  constructor(username) {
     this.username = username;
-    this.identity = {
-      username,
-      devices: [],
-    };
+    this.filePath = path.join(ROOT_DIR, `${username}.me`); // encrypted .me file path
+    this.unlocked = false; // will become true after decrypting with correct hash
+    this.data = null; // holds decrypted data (identity, keys, attributes, etc.)
+  }
 
-    this.addDevice(); // Automatically adds the current device
-    Me.registry[username] = this.identity;
-    Registry.save(Me.registry);
+  /**
+   * Encrypt and write the current `this.data` to disk.
+   */
+  save(hash) {
+    if (!this.data) throw new Error('No data to save');
+    const iv = crypto.randomBytes(16);
+    const key = crypto.createHash('sha256').update(hash).digest();
+    const cipher = crypto.createCipheriv('aes-256-cbc', key, iv);
+    const encrypted = Buffer.concat([
+      iv,
+      cipher.update(JSON.stringify(this.data)),
+      cipher.final()
+    ]);
+    fs.writeFileSync(this.filePath, encrypted);
   }
 
-  static load(username) {
-    if (!Me.registry[username]) {
-      throw new Error(`Username ${username} does not exist.`);
+  /**
+   * Unlock the .me file by decrypting it using the provided hash.
+   */
+  unlock(hash) {
+    const fileBuffer = fs.readFileSync(this.filePath);
+    const iv = fileBuffer.slice(0, 16);
+    const encryptedData = fileBuffer.slice(16);
+    const key = crypto.createHash('sha256').update(hash).digest();
+    try {
+      const decipher = crypto.createDecipheriv('aes-256-cbc', key, iv);
+      const decrypted = Buffer.concat([
+        decipher.update(encryptedData),
+        decipher.final()
+      ]);
+      this.data = JSON.parse(decrypted.toString('utf-8'));
+      this.unlocked = true;
+      return true;
+    } catch (err) {
+      return false; // incorrect hash or corrupted file
     }
-    return new Me(username, Me.registry[username]);
   }
 
-  addDevice(deviceInfo = null) {
-    const device = deviceInfo || {
-      deviceId: crypto.randomUUID(),
-      hostname: os.hostname(),
-      platform: os.platform(),
-      isPrimary: this.identity.devices.length === 0,
+  /**
+   * Locks the session by wiping in-memory data.
+   */
+  lock() {
+    this.data = null;
+    this.unlocked = false;
+  }
+
+ /**
+   * Create a new identity file for the given username.
+   * Called only if it doesn't already exist.
+   */
+ static create(username, hash) {
+  const me = new Me(username);
+  if (fs.existsSync(me.filePath)) {
+    throw new Error('Identity already exists');
+  }
+
+  // Generate keys or initial structure
+  me.data = {
+    identity: {
+      username,
+      publicKey: 'publicKeyPlaceholder', // later generate real keypair
+      privateKey: 'privateKeyPlaceholder'
+    },
+    attributes: {},
+    relationships: [],
+    reactions: [],
+    endorsements: []
+  };
+
+  me.save(hash);
+  return me;
+}
+
+  /**
+   * Create a new identity file for the given username.
+   * Called only if it doesn't already exist.
+   */
+  static create(username, hash) {
+    const me = new Me(username);
+    if (fs.existsSync(me.filePath)) {
+      throw new Error('Identity already exists');
+    }
+
+    // Generate keys or initial structure
+    me.data = {
+      identity: {
+        username,
+        publicKey: 'publicKeyPlaceholder', // later generate real keypair
+        privateKey: 'privateKeyPlaceholder'
+      },
+      attributes: {},
+      relationships: [],
+      reactions: [],
+      endorsements: []
     };
 
-    this.identity.devices.push(device);
-    Registry.save(Me.registry);
+    me.save(hash);
+    return me;
   }
 
-  removeDevice(deviceId) {
-    this.identity.devices = this.identity.devices.filter((d) => d.deviceId !== deviceId);
-    Registry.save(Me.registry);
+  /**
+   * Load and decrypt an existing identity.
+   */
+  static load(username, hash) {
+    const me = new Me(username);
+    const success = me.unlock(hash);
+    if (!success) throw new Error('Invalid hash or corrupted file');
+    return me;
+  }
+  /**
+   * Add an endorsement (external signature asserting trust in this identity).
+   */
+  addEndorsement(endorsement) {
+    if (!this.unlocked) throw new Error('Identity is locked');
+    this.data.endorsements.push(endorsement);
   }
 
-  listDevices() {
-    return this.identity.devices;
+  /**
+   * Example: add an attribute to this.me (like `.be("artist")`).
+   */
+  be(key, value) {
+    if (!this.unlocked) throw new Error('Identity is locked');
+    this.data.attributes[key] = value;
   }
 
-  static getAllUsers() {
-    return Object.keys(Me.registry);
+  getAttributes() {
+    if (!this.unlocked) throw new Error('Identity is locked');
+    return this.data.attributes;
   }
 }
 

package/src/methods/attributes.js

@@ -0,0 +1,79 @@
+ // Attributes methods
+ /**
+ * @module Attributes
+ * @description Methods to manage attributes for the `Me` class, with key-vaue pairs.
+ */
+/**
+   * @description Adds or updates an attribute for the `me` instance.
+   * 
+   * This method allows you to dynamically add or update descriptive attributes 
+   * for the `me` instance. Attributes are stored as key-value pairs, where:
+   * - The **key** represents the name of the attribute (e.g., "name", "age", "location").
+   * - The **value** represents the data associated with that attribute (e.g., "Sui Gn", 30, "Earth").
+   * 
+   * You can add as many key-value pairs as you want, giving you the flexibility to describe 
+   * the `me` instance with plain data. The attributes are stored in an object, and each call 
+   * to `be` either adds a new attribute or updates an existing one if the key already exists.
+   * 
+   * This approach ensures that the `me` instance can evolve and be customized over time 
+   * with additional or modified attributes as needed.
+   * 
+   * @param {string} key - The attribute key (e.g., "name").
+   * @param {string|number|boolean|Object} value - The attribute value associated with the key. 
+   *   This can be any data type (e.g., string, number, boolean, or even a nested object).
+   * 
+   * @example
+   * // Adding a single attribute
+   * me.be("name", "Sui Gn");
+   * console.log(me.getAttributes()); // { name: "Sui Gn" }
+   * 
+   * // Adding multiple attributes
+   * me.be("age", 30);
+   * me.be("location", "Earth");
+   * console.log(me.getAttributes()); 
+   * // Output: { name: "Sui Gn", age: 30, location: "Earth" }
+   * 
+   * // Updating an existing attribute
+   * me.be("name", "John Doe");
+   * console.log(me.getAttributes()); 
+   * // Output: { name: "John Doe", age: 30, location: "Earth" }
+   * 
+   * // Using complex data types
+   * me.be("preferences", { theme: "dark", language: "en" });
+   * console.log(me.getAttributes());
+   * // Output: { name: "John Doe", age: 30, location: "Earth", preferences: { theme: "dark", language: "en" } }
+   */
+export function be(attributes, key, value) {
+    if (!key || typeof key !== 'string') {
+        throw new Error('Invalid key for attribute');
+    }
+    attributes[key] = value;
+  }
+  /**
+     * @description Retrieves all attributes associated with the `me` instance.
+     * 
+     * This method provides access to the current set of attributes stored in the `me` instance 
+     * as an object containing key-value pairs. Each key represents the name of an attribute, 
+     * and its corresponding value represents the data stored for that attribute.
+     * 
+     * You can either:
+     * - Retrieve all attributes at once as a single object.
+     * - Access specific attributes directly using their keys.
+     * 
+     * @returns {Object} An object containing all the key-value pairs representing 
+     * the attributes of the `me` instance.
+     * 
+     * @example
+     * // Retrieving all attributes
+     * console.log(me.getAttributes()); 
+     * // Output: { name: "Sui Gn", age: 30, location: "Earth" }
+     * 
+     * // Accessing specific attributes by their key
+     * const attributes = me.getAttributes();
+     * console.log(attributes.name); // "Sui Gn"
+     * console.log(attributes.age); // 30
+     * console.log(attributes.location); // "Earth"
+     */
+  export function getAttributes(attributes) {
+    return attributes;
+  }

package/src/methods/identity.js

@@ -0,0 +1,31 @@
+/**
+ * @module Identity
+ * @description Methods to manage identity for the `Me` class.
+ */
+
+/**
+ * Sets up the identity for a `Me` instance.
+ * @function
+ * @param {string} username - The username to set for the identity.
+ * @returns {Object} The identity object containing the username.
+ * 
+ * @example
+ * const identity = setup("suiGn");
+ * console.log(identity); // { username: "suiGn" }
+ */
+export function setup(username) {
+  return { username };
+}
+
+/**
+* Retrieves the username (identity) of the `Me` instance.
+* @function
+* @param {Object} identity - The identity object of the `Me` instance.
+* @returns {Object} The `Me` username identity object.
+* 
+* @example
+* console.log(getMe({ username: "suiGn" })); // { username: "suiGn" }
+*/
+export function getMe(identity) {
+  return identity;
+}

package/src/methods/properties.js

@@ -0,0 +1,73 @@
+// this.me/src/methods/properties.js
+/**
+ * @module Properties
+ * @description Methods to manage properties for the `Me` class.
+ */
+
+/**
+ * Validates a property before adding it.
+ * @function
+ * @param {Object} property - The property to validate.
+ * @throws {Error} If the property is invalid.
+ */
+function validateProperty(property) {
+  if (!property || typeof property !== 'object') {
+    throw new Error('Invalid property: Must be a non-null object.');
+  }
+}
+
+/**
+ * Adds a property to the identity.
+ * @function
+ * @param {Array} properties - The properties array to update.
+ * @param {Object} property - The property to add (e.g., { type: "ETH", address: "0x123..." }).
+ */
+function addProperty(properties, property) {
+  validateProperty(property);
+  properties.push(property);
+}
+
+/**
+ * Retrieves all properties for the identity.
+ * @function
+ * @param {Array} properties - The properties array to retrieve from.
+ * @returns {Array} The properties array.
+ */
+function getProperties(properties) {
+  return [...properties]; // Return a shallow copy to prevent mutation outside
+}
+
+/**
+ * Removes a property from the identity.
+ * @function
+ * @param {Array} properties - The properties array to update.
+ * @param {Object} property - The property to remove.
+ */
+function removeProperty(properties, property) {
+  validateProperty(property);
+  const index = properties.findIndex(p => JSON.stringify(p) === JSON.stringify(property));
+  if (index !== -1) properties.splice(index, 1);
+}
+
+/**
+ * Checks if a specific property exists.
+ * @function
+ * @param {Array} properties - The properties array.
+ * @param {Object} property - The property to check.
+ * @returns {boolean} True if the property exists, otherwise false.
+ */
+function hasProperty(properties, property) {
+  validateProperty(property);
+  return properties.some(p => JSON.stringify(p) === JSON.stringify(property));
+}
+
+// Named exports
+export { addProperty, getProperties, removeProperty, hasProperty };
+
+// Default export (optional for easier import as an object)
+export default {
+  addProperty,
+  getProperties,
+  removeProperty,
+  hasProperty
+};

package/src/methods/reactions.js

@@ -0,0 +1,31 @@
+//this.me/src/methods/reactions.js
+/**
+ * @module Reactions
+ * @description Methods to manage reactions for the `Me` class.
+ */
+/**
+ * Add a reaction to a target.
+ * @function
+ * @param {Array} reactions - The reactions array to update.
+ * @param {string} type - The type of reaction (e.g., "like", "comment").
+ * @param {string} target - The target of the reaction (e.g., "PostID").
+ * @param {string} [content=null] - Additional content for the reaction (e.g., a comment).
+ * @throws {Error} If the type or target is invalid.
+ */
+export function react(reactions, type, target, content = null) {
+    if (!type || !target) {
+      throw new Error('Invalid reaction parameters');
+    }
+    reactions.push({ type, target, content, timestamp: new Date() });
+  }
+  
+  /**
+   * Retrieve all reactions for the identity.
+   * @function
+   * @param {Array} reactions - The reactions array to retrieve from.
+   * @returns {Array} The reactions array.
+   * @instance
+   */
+  export function getReactions(reactions) {
+    return reactions;
+  }

package/src/methods/relationships.js

@@ -0,0 +1,26 @@
+/**
+ * @module Relationships
+ * @description Manages user relationships.
+ */
+
+// Function to add a relationship
+export function addRelationship(relationships, relationship) {
+  if (!relationship || !relationship.type || !relationship.username) {
+    throw new Error('Invalid relationship object. Must include type and username.');
+  }
+
+  relationships.push(relationship);
+}
+
+// Function to retrieve relationships
+export function getRelationships(relationships, type = null) {
+  if (type) {
+    return relationships.filter(rel => rel.type === type);
+  }
+  return relationships;
+}
+
+// Function to initialize relationships for a user
+export function createRelationships() {
+  return [];
+}

package/src/scripts/setup.js

@@ -0,0 +1,19 @@
+// setup.js
+import { mkdirSync, existsSync } from 'fs';
+import { homedir } from 'os';
+import path from 'path';
+const root = path.join(homedir(), '.this');
+const mePath = path.join(root, 'me');
+if (!existsSync(root)) {
+  mkdirSync(root);
+  console.log('✅ Created ~/.this root directory');
+} else {
+  console.log('✅ ~/.this root directory already exists');
+}
+
+if (!existsSync(mePath)) {
+  mkdirSync(mePath);
+  console.log('✅ Created ~/.this/me directory');
+} else {
+  console.log('✅ ~/.this/me directory already exists');
+}

package/src/scripts/setup_validation.js

@@ -0,0 +1,31 @@
+import { existsSync, mkdirSync } from 'fs';
+import { homedir } from 'os';
+import path from 'path';
+
+const root = path.join(homedir(), '.this');
+const mePath = path.join(root, 'me');
+
+export function validateSetup() {
+  let updated = false;
+
+  if (!existsSync(root)) {
+    mkdirSync(root);
+    console.log('✅ Created ~/.this root directory');
+    updated = true;
+  }
+
+  if (!existsSync(mePath)) {
+    mkdirSync(mePath);
+    console.log('✅ Created ~/.this/me directory');
+    updated = true;
+  }
+
+  if (!updated) {
+    console.log('.me >> init.');
+  }
+}
+
+// Run directly if script is executed as entry point
+if (import.meta.url === `file://${process.argv[1]}`) {
+  validateSetup();
+}

package/src/.me.cli.js

@@ -1,20 +0,0 @@
-#!/usr/bin/env node
-//.me.cli.js
-import { program } from 'commander';
-import { meMainChoices } from './CLI/me_MainChoices.js';
-import AddMe from './CLI/AddMe.js'; 
-import LogMe from './CLI/LogMe.js'; 
-program
-  .description('.Me Command Line Interface')
-  .version('1.0.0')
-  .action(meMainChoices);
-
-program.command('add-me')
-  .description('+ Add .me')
-  .action(AddMe);
-
-program.command('log-me')
-  .description('Log .me')
-  .action(LogMe);
-
-program.parse(process.argv);